src/src/tls-openssl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2014 */
   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 DISABLE_OCSP
  26 # include <openssl/ocsp.h>
  27 #endif
  28 #ifdef EXPERIMENTAL_DANE
  29 # include <danessl.h>
  30 #endif
  31
  32
  33 #ifndef DISABLE_OCSP
  34 # define EXIM_OCSP_SKEW_SECONDS (300L)
  35 # define EXIM_OCSP_MAX_AGE (-1L)
  36 #endif
  37
  38 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
  39 # define EXIM_HAVE_OPENSSL_TLSEXT
  40 #endif
  41 #if OPENSSL_VERSION_NUMBER >= 0x010100000L
  42 # define EXIM_HAVE_OPENSSL_CHECKHOST
  43 #endif
  44 #if OPENSSL_VERSION_NUMBER >= 0x010000000L \
  45     && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
  46 # define EXIM_HAVE_OPENSSL_CHECKHOST
  47 #endif
  48
  49 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
  50 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
  51 # define DISABLE_OCSP
  52 #endif
  53
  54 /* Structure for collecting random data for seeding. */
  55
  56 typedef struct randstuff {
  57   struct timeval tv;
  58   pid_t          p;
  59 } randstuff;
  60
  61 /* Local static variables */
  62
  63 static BOOL client_verify_callback_called = FALSE;
  64 static BOOL server_verify_callback_called = FALSE;
  65 static const uschar *sid_ctx = US"exim";
  66
  67 /* We have three different contexts to care about.
  68
  69 Simple case: client, `client_ctx`
  70  As a client, we can be doing a callout or cut-through delivery while receiving
  71  a message.  So we have a client context, which should have options initialised
  72  from the SMTP Transport.
  73
  74 Server:
  75  There are two cases: with and without ServerNameIndication from the client.
  76  Given TLS SNI, we can be using different keys, certs and various other
  77  configuration settings, because they're re-expanded with $tls_sni set.  This
  78  allows vhosting with TLS.  This SNI is sent in the handshake.
  79  A client might not send SNI, so we need a fallback, and an initial setup too.
  80  So as a server, we start out using `server_ctx`.
  81  If SNI is sent by the client, then we as server, mid-negotiation, try to clone
  82  `server_sni` from `server_ctx` and then initialise settings by re-expanding
  83  configuration.
  84 */
  85
  86 static SSL_CTX *client_ctx = NULL;
  87 static SSL_CTX *server_ctx = NULL;
  88 static SSL     *client_ssl = NULL;
  89 static SSL     *server_ssl = NULL;
  90
  91 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
  92 static SSL_CTX *server_sni = NULL;
  93 #endif
  94
  95 static char ssl_errstring[256];
  96
  97 static int  ssl_session_timeout = 200;
  98 static BOOL client_verify_optional = FALSE;
  99 static BOOL server_verify_optional = FALSE;
 100
 101 static BOOL reexpand_tls_files_for_sni = FALSE;
 102
 103
 104 typedef struct tls_ext_ctx_cb {
 105   uschar *certificate;
 106   uschar *privatekey;
 107 #ifndef DISABLE_OCSP
 108   BOOL is_server;
 109   union {
 110     struct {
 111       uschar        *file;
 112       uschar        *file_expanded;
 113       OCSP_RESPONSE *response;
 114     } server;
 115     struct {
 116       X509_STORE    *verify_store;      /* non-null if status requested */
 117       BOOL          verify_required;
 118     } client;
 119   } u_ocsp;
 120 #endif
 121   uschar *dhparam;
 122   /* these are cached from first expand */
 123   uschar *server_cipher_list;
 124   /* only passed down to tls_error: */
 125   host_item *host;
 126
 127 #ifdef EXPERIMENTAL_CERTNAMES
 128   uschar * verify_cert_hostnames;
 129 #endif
 130 #ifdef EXPERIMENTAL_EVENT
 131   uschar * event_action;
 132 #endif
 133 } tls_ext_ctx_cb;
 134
 135 /* should figure out a cleanup of API to handle state preserved per
 136 implementation, for various reasons, which can be void * in the APIs.
 137 For now, we hack around it. */
 138 tls_ext_ctx_cb *client_static_cbinfo = NULL;
 139 tls_ext_ctx_cb *server_static_cbinfo = NULL;
 140
 141 static int
 142 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
 143     int (*cert_vfy_cb)(int, X509_STORE_CTX *) );
 144
 145 /* Callbacks */
 146 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 147 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
 148 #endif
 149 #ifndef DISABLE_OCSP
 150 static int tls_server_stapling_cb(SSL *s, void *arg);
 151 #endif
 152
 153
 154 /*************************************************
 155 *               Handle TLS error                 *
 156 *************************************************/
 157
 158 /* Called from lots of places when errors occur before actually starting to do
 159 the TLS handshake, that is, while the session is still in clear. Always returns
 160 DEFER for a server and FAIL for a client so that most calls can use "return
 161 tls_error(...)" to do this processing and then give an appropriate return. A
 162 single function is used for both server and client, because it is called from
 163 some shared functions.
 164
 165 Argument:
 166   prefix    text to include in the logged error
 167   host      NULL if setting up a server;
 168             the connected host if setting up a client
 169   msg       error message or NULL if we should ask OpenSSL
 170
 171 Returns:    OK/DEFER/FAIL
 172 */
 173
 174 static int
 175 tls_error(uschar *prefix, host_item *host, uschar *msg)
 176 {
 177 if (!msg)
 178   {
 179   ERR_error_string(ERR_get_error(), ssl_errstring);
 180   msg = (uschar *)ssl_errstring;
 181   }
 182
 183 if (host)
 184   {
 185   log_write(0, LOG_MAIN, "H=%s [%s] TLS error on connection (%s): %s",
 186     host->name, host->address, prefix, msg);
 187   return FAIL;
 188   }
 189 else
 190   {
 191   uschar *conn_info = smtp_get_connection_info();
 192   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0)
 193     conn_info += 5;
 194   /* I'd like to get separated H= here, but too hard for now */
 195   log_write(0, LOG_MAIN, "TLS error on %s (%s): %s",
 196     conn_info, prefix, msg);
 197   return DEFER;
 198   }
 199 }
 200
 201
 202
 203 /*************************************************
 204 *        Callback to generate RSA key            *
 205 *************************************************/
 206
 207 /*
 208 Arguments:
 209   s          SSL connection
 210   export     not used
 211   keylength  keylength
 212
 213 Returns:     pointer to generated key
 214 */
 215
 216 static RSA *
 217 rsa_callback(SSL *s, int export, int keylength)
 218 {
 219 RSA *rsa_key;
 220 export = export;     /* Shut picky compilers up */
 221 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
 222 rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL);
 223 if (rsa_key == NULL)
 224   {
 225   ERR_error_string(ERR_get_error(), ssl_errstring);
 226   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
 227     ssl_errstring);
 228   return NULL;
 229   }
 230 return rsa_key;
 231 }
 232
 233
 234
 235 /* Extreme debug
 236 #ifndef DISABLE_OCSP
 237 void
 238 x509_store_dump_cert_s_names(X509_STORE * store)
 239 {
 240 STACK_OF(X509_OBJECT) * roots= store->objs;
 241 int i;
 242 static uschar name[256];
 243
 244 for(i= 0; i<sk_X509_OBJECT_num(roots); i++)
 245   {
 246   X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
 247   if(tmp_obj->type == X509_LU_X509)
 248     {
 249     X509 * current_cert= tmp_obj->data.x509;
 250     X509_NAME_oneline(X509_get_subject_name(current_cert), CS name, sizeof(name));
 251     debug_printf(" %s\n", name);
 252     }
 253   }
 254 }
 255 #endif
 256 */
 257
 258
 259 /*************************************************
 260 *        Callback for verification               *
 261 *************************************************/
 262
 263 /* The SSL library does certificate verification if set up to do so. This
 264 callback has the current yes/no state is in "state". If verification succeeded,
 265 we set up the tls_peerdn string. If verification failed, what happens depends
 266 on whether the client is required to present a verifiable certificate or not.
 267
 268 If verification is optional, we change the state to yes, but still log the
 269 verification error. For some reason (it really would help to have proper
 270 documentation of OpenSSL), this callback function then gets called again, this
 271 time with state = 1. In fact, that's useful, because we can set up the peerdn
 272 value, but we must take care not to set the private verified flag on the second
 273 time through.
 274
 275 Note: this function is not called if the client fails to present a certificate
 276 when asked. We get here only if a certificate has been received. Handling of
 277 optional verification for this case is done when requesting SSL to verify, by
 278 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
 279
 280 May be called multiple times for different issues with a certificate, even
 281 for a given "depth" in the certificate chain.
 282
 283 Arguments:
 284   state      current yes/no state as 1/0
 285   x509ctx    certificate information.
 286   client     TRUE for client startup, FALSE for server startup
 287
 288 Returns:     1 if verified, 0 if not
 289 */
 290
 291 static int
 292 verify_callback(int state, X509_STORE_CTX *x509ctx,
 293   tls_support *tlsp, BOOL *calledp, BOOL *optionalp)
 294 {
 295 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
 296 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
 297 uschar * ev;
 298 static uschar txt[256];
 299
 300 X509_NAME_oneline(X509_get_subject_name(cert), CS txt, sizeof(txt));
 301
 302 if (state == 0)
 303   {
 304   log_write(0, LOG_MAIN, "SSL verify error: depth=%d error=%s cert=%s",
 305     depth,
 306     X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)),
 307     txt);
 308   tlsp->certificate_verified = FALSE;
 309   *calledp = TRUE;
 310   if (!*optionalp)
 311     {
 312     tlsp->peercert = X509_dup(cert);
 313     return 0;                       /* reject */
 314     }
 315   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
 316     "tls_try_verify_hosts)\n");
 317   }
 318
 319 else if (depth != 0)
 320   {
 321   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, txt);
 322 #ifndef DISABLE_OCSP
 323   if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
 324     {   /* client, wanting stapling  */
 325     /* Add the server cert's signing chain as the one
 326     for the verification of the OCSP stapled information. */
 327
 328     if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
 329                              cert))
 330       ERR_clear_error();
 331     }
 332 #endif
 333 #ifdef EXPERIMENTAL_EVENT
 334   ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
 335   if (ev)
 336     {
 337     tlsp->peercert = X509_dup(cert);
 338     if (event_raise(ev, US"tls:cert", string_sprintf("%d", depth)) == DEFER)
 339       {
 340       log_write(0, LOG_MAIN, "SSL verify denied by event-action: "
 341                               "depth=%d cert=%s", depth, txt);
 342       tlsp->certificate_verified = FALSE;
 343       *calledp = TRUE;
 344       return 0;                     /* reject */
 345       }
 346     X509_free(tlsp->peercert);
 347     tlsp->peercert = NULL;
 348     }
 349 #endif
 350   }
 351 else
 352   {
 353 #ifdef EXPERIMENTAL_CERTNAMES
 354   uschar * verify_cert_hostnames;
 355 #endif
 356
 357   tlsp->peerdn = txt;
 358   tlsp->peercert = X509_dup(cert);
 359
 360 #ifdef EXPERIMENTAL_CERTNAMES
 361   if (  tlsp == &tls_out
 362      && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
 363         /* client, wanting hostname check */
 364
 365 # if EXIM_HAVE_OPENSSL_CHECKHOST
 366 #  ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
 367 #   define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
 368 #  endif
 369 #  ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
 370 #   define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
 371 #  endif
 372     {
 373     int sep = 0;
 374     uschar * list = verify_cert_hostnames;
 375     uschar * name;
 376     int rc;
 377     while ((name = string_nextinlist(&list, &sep, NULL, 0)))
 378       if ((rc = X509_check_host(cert, name, 0,
 379                   X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
 380                   | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS)))
 381         {
 382         if (rc < 0)
 383           {
 384           log_write(0, LOG_MAIN, "SSL verify error: internal error\n");
 385           name = NULL;
 386           }
 387         break;
 388         }
 389     if (!name)
 390       {
 391       log_write(0, LOG_MAIN,
 392         "SSL verify error: certificate name mismatch: \"%s\"\n", txt);
 393       return 0;                         /* reject */
 394       }
 395     }
 396 # else
 397     if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
 398       {
 399       log_write(0, LOG_MAIN,
 400         "SSL verify error: certificate name mismatch: \"%s\"\n", txt);
 401       return 0;                         /* reject */
 402       }
 403 # endif
 404 #endif  /*EXPERIMENTAL_CERTNAMES*/
 405
 406 #ifdef EXPERIMENTAL_EVENT
 407   ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
 408   if (ev)
 409     if (event_raise(ev, US"tls:cert", US"0") == DEFER)
 410       {
 411       log_write(0, LOG_MAIN, "SSL verify denied by event-action: "
 412                               "depth=0 cert=%s", txt);
 413       tlsp->certificate_verified = FALSE;
 414       *calledp = TRUE;
 415       return 0;                     /* reject */
 416       }
 417 #endif
 418
 419   DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
 420     *calledp ? "" : " authenticated", txt);
 421   if (!*calledp) tlsp->certificate_verified = TRUE;
 422   *calledp = TRUE;
 423   }
 424
 425 return 1;   /* accept, at least for this level */
 426 }
 427
 428 static int
 429 verify_callback_client(int state, X509_STORE_CTX *x509ctx)
 430 {
 431 return verify_callback(state, x509ctx, &tls_out, &client_verify_callback_called, &client_verify_optional);
 432 }
 433
 434 static int
 435 verify_callback_server(int state, X509_STORE_CTX *x509ctx)
 436 {
 437 return verify_callback(state, x509ctx, &tls_in, &server_verify_callback_called, &server_verify_optional);
 438 }
 439
 440
 441 #ifdef EXPERIMENTAL_DANE
 442
 443 /* This gets called *by* the dane library verify callback, which interposes
 444 itself.
 445 */
 446 static int
 447 verify_callback_client_dane(int state, X509_STORE_CTX * x509ctx)
 448 {
 449 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
 450 static uschar txt[256];
 451 #ifdef EXPERIMENTAL_EVENT
 452 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
 453 #endif
 454
 455 X509_NAME_oneline(X509_get_subject_name(cert), CS txt, sizeof(txt));
 456
 457 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s\n", txt);
 458 tls_out.peerdn = txt;
 459 tls_out.peercert = X509_dup(cert);
 460
 461 #ifdef EXPERIMENTAL_EVENT
 462   if (client_static_cbinfo->event_action)
 463     {
 464     if (event_raise(client_static_cbinfo->event_action,
 465                     US"tls:cert", string_sprintf("%d", depth)) == DEFER)
 466       {
 467       log_write(0, LOG_MAIN, "DANE verify denied by event-action: "
 468                               "depth=%d cert=%s", depth, txt);
 469       tls_out.certificate_verified = FALSE;
 470       return 0;                     /* reject */
 471       }
 472     if (depth != 0)
 473       {
 474       X509_free(tls_out.peercert);
 475       tls_out.peercert = NULL;
 476       }
 477     }
 478 #endif
 479
 480 if (state == 1)
 481   tls_out.dane_verified =
 482   tls_out.certificate_verified = TRUE;
 483 return 1;
 484 }
 485
 486 #endif  /*EXPERIMENTAL_DANE*/
 487
 488
 489 /*************************************************
 490 *           Information callback                 *
 491 *************************************************/
 492
 493 /* The SSL library functions call this from time to time to indicate what they
 494 are doing. We copy the string to the debugging output when TLS debugging has
 495 been requested.
 496
 497 Arguments:
 498   s         the SSL connection
 499   where
 500   ret
 501
 502 Returns:    nothing
 503 */
 504
 505 static void
 506 info_callback(SSL *s, int where, int ret)
 507 {
 508 where = where;
 509 ret = ret;
 510 DEBUG(D_tls) debug_printf("SSL info: %s\n", SSL_state_string_long(s));
 511 }
 512
 513
 514
 515 /*************************************************
 516 *                Initialize for DH               *
 517 *************************************************/
 518
 519 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
 520
 521 Arguments:
 522   dhparam   DH parameter file or fixed parameter identity string
 523   host      connected host, if client; NULL if server
 524
 525 Returns:    TRUE if OK (nothing to set up, or setup worked)
 526 */
 527
 528 static BOOL
 529 init_dh(SSL_CTX *sctx, uschar *dhparam, host_item *host)
 530 {
 531 BIO *bio;
 532 DH *dh;
 533 uschar *dhexpanded;
 534 const char *pem;
 535
 536 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded))
 537   return FALSE;
 538
 539 if (!dhexpanded || !*dhexpanded)
 540   bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
 541 else if (dhexpanded[0] == '/')
 542   {
 543   if (!(bio = BIO_new_file(CS dhexpanded, "r")))
 544     {
 545     tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
 546           host, US strerror(errno));
 547     return FALSE;
 548     }
 549   }
 550 else
 551   {
 552   if (Ustrcmp(dhexpanded, "none") == 0)
 553     {
 554     DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
 555     return TRUE;
 556     }
 557
 558   if (!(pem = std_dh_prime_named(dhexpanded)))
 559     {
 560     tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
 561         host, US strerror(errno));
 562     return FALSE;
 563     }
 564   bio = BIO_new_mem_buf(CS pem, -1);
 565   }
 566
 567 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
 568   {
 569   BIO_free(bio);
 570   tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
 571       host, NULL);
 572   return FALSE;
 573   }
 574
 575 /* Even if it is larger, we silently return success rather than cause things
 576  * to fail out, so that a too-large DH will not knock out all TLS; it's a
 577  * debatable choice. */
 578 if ((8*DH_size(dh)) > tls_dh_max_bits)
 579   {
 580   DEBUG(D_tls)
 581     debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d",
 582         8*DH_size(dh), tls_dh_max_bits);
 583   }
 584 else
 585   {
 586   SSL_CTX_set_tmp_dh(sctx, dh);
 587   DEBUG(D_tls)
 588     debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
 589       dhexpanded ? dhexpanded : US"default", 8*DH_size(dh));
 590   }
 591
 592 DH_free(dh);
 593 BIO_free(bio);
 594
 595 return TRUE;
 596 }
 597
 598
 599
 600
 601 #ifndef DISABLE_OCSP
 602 /*************************************************
 603 *       Load OCSP information into state         *
 604 *************************************************/
 605
 606 /* Called to load the server OCSP response from the given file into memory, once
 607 caller has determined this is needed.  Checks validity.  Debugs a message
 608 if invalid.
 609
 610 ASSUMES: single response, for single cert.
 611
 612 Arguments:
 613   sctx            the SSL_CTX* to update
 614   cbinfo          various parts of session state
 615   expanded        the filename putatively holding an OCSP response
 616
 617 */
 618
 619 static void
 620 ocsp_load_response(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo, const uschar *expanded)
 621 {
 622 BIO *bio;
 623 OCSP_RESPONSE *resp;
 624 OCSP_BASICRESP *basic_response;
 625 OCSP_SINGLERESP *single_response;
 626 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
 627 X509_STORE *store;
 628 unsigned long verify_flags;
 629 int status, reason, i;
 630
 631 cbinfo->u_ocsp.server.file_expanded = string_copy(expanded);
 632 if (cbinfo->u_ocsp.server.response)
 633   {
 634   OCSP_RESPONSE_free(cbinfo->u_ocsp.server.response);
 635   cbinfo->u_ocsp.server.response = NULL;
 636   }
 637
 638 bio = BIO_new_file(CS cbinfo->u_ocsp.server.file_expanded, "rb");
 639 if (!bio)
 640   {
 641   DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
 642       cbinfo->u_ocsp.server.file_expanded);
 643   return;
 644   }
 645
 646 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
 647 BIO_free(bio);
 648 if (!resp)
 649   {
 650   DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
 651   return;
 652   }
 653
 654 status = OCSP_response_status(resp);
 655 if (status != OCSP_RESPONSE_STATUS_SUCCESSFUL)
 656   {
 657   DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
 658       OCSP_response_status_str(status), status);
 659   goto bad;
 660   }
 661
 662 basic_response = OCSP_response_get1_basic(resp);
 663 if (!basic_response)
 664   {
 665   DEBUG(D_tls)
 666     debug_printf("OCSP response parse error: unable to extract basic response.\n");
 667   goto bad;
 668   }
 669
 670 store = SSL_CTX_get_cert_store(sctx);
 671 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
 672
 673 /* May need to expose ability to adjust those flags?
 674 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
 675 OCSP_TRUSTOTHER OCSP_NOINTERN */
 676
 677 i = OCSP_basic_verify(basic_response, NULL, store, verify_flags);
 678 if (i <= 0)
 679   {
 680   DEBUG(D_tls) {
 681     ERR_error_string(ERR_get_error(), ssl_errstring);
 682     debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
 683     }
 684   goto bad;
 685   }
 686
 687 /* Here's the simplifying assumption: there's only one response, for the
 688 one certificate we use, and nothing for anything else in a chain.  If this
 689 proves false, we need to extract a cert id from our issued cert
 690 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
 691 right cert in the stack and then calls OCSP_single_get0_status()).
 692
 693 I'm hoping to avoid reworking a bunch more of how we handle state here. */
 694 single_response = OCSP_resp_get0(basic_response, 0);
 695 if (!single_response)
 696   {
 697   DEBUG(D_tls)
 698     debug_printf("Unable to get first response from OCSP basic response.\n");
 699   goto bad;
 700   }
 701
 702 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
 703 if (status != V_OCSP_CERTSTATUS_GOOD)
 704   {
 705   DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
 706       OCSP_cert_status_str(status), status,
 707       OCSP_crl_reason_str(reason), reason);
 708   goto bad;
 709   }
 710
 711 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
 712   {
 713   DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
 714   goto bad;
 715   }
 716
 717 supply_response:
 718   cbinfo->u_ocsp.server.response = resp;
 719 return;
 720
 721 bad:
 722   if (running_in_test_harness)
 723     {
 724     extern char ** environ;
 725     uschar ** p;
 726     for (p = USS environ; *p != NULL; p++)
 727       if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
 728         {
 729         DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
 730         goto supply_response;
 731         }
 732     }
 733 return;
 734 }
 735 #endif  /*!DISABLE_OCSP*/
 736
 737
 738
 739
 740 /*************************************************
 741 *        Expand key and cert file specs          *
 742 *************************************************/
 743
 744 /* Called once during tls_init and possibly again during TLS setup, for a
 745 new context, if Server Name Indication was used and tls_sni was seen in
 746 the certificate string.
 747
 748 Arguments:
 749   sctx            the SSL_CTX* to update
 750   cbinfo          various parts of session state
 751
 752 Returns:          OK/DEFER/FAIL
 753 */
 754
 755 static int
 756 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo)
 757 {
 758 uschar *expanded;
 759
 760 if (cbinfo->certificate == NULL)
 761   return OK;
 762
 763 if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
 764     Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
 765     Ustrstr(cbinfo->certificate, US"tls_out_sni")
 766    )
 767   reexpand_tls_files_for_sni = TRUE;
 768
 769 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded))
 770   return DEFER;
 771
 772 if (expanded != NULL)
 773   {
 774   DEBUG(D_tls) debug_printf("tls_certificate file %s\n", expanded);
 775   if (!SSL_CTX_use_certificate_chain_file(sctx, CS expanded))
 776     return tls_error(string_sprintf(
 777       "SSL_CTX_use_certificate_chain_file file=%s", expanded),
 778         cbinfo->host, NULL);
 779   }
 780
 781 if (cbinfo->privatekey != NULL &&
 782     !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded))
 783   return DEFER;
 784
 785 /* If expansion was forced to fail, key_expanded will be NULL. If the result
 786 of the expansion is an empty string, ignore it also, and assume the private
 787 key is in the same file as the certificate. */
 788
 789 if (expanded != NULL && *expanded != 0)
 790   {
 791   DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", expanded);
 792   if (!SSL_CTX_use_PrivateKey_file(sctx, CS expanded, SSL_FILETYPE_PEM))
 793     return tls_error(string_sprintf(
 794       "SSL_CTX_use_PrivateKey_file file=%s", expanded), cbinfo->host, NULL);
 795   }
 796
 797 #ifndef DISABLE_OCSP
 798 if (cbinfo->is_server &&  cbinfo->u_ocsp.server.file != NULL)
 799   {
 800   if (!expand_check(cbinfo->u_ocsp.server.file, US"tls_ocsp_file", &expanded))
 801     return DEFER;
 802
 803   if (expanded != NULL && *expanded != 0)
 804     {
 805     DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
 806     if (cbinfo->u_ocsp.server.file_expanded &&
 807         (Ustrcmp(expanded, cbinfo->u_ocsp.server.file_expanded) == 0))
 808       {
 809       DEBUG(D_tls)
 810         debug_printf("tls_ocsp_file value unchanged, using existing values.\n");
 811       } else {
 812         ocsp_load_response(sctx, cbinfo, expanded);
 813       }
 814     }
 815   }
 816 #endif
 817
 818 return OK;
 819 }
 820
 821
 822
 823
 824 /*************************************************
 825 *            Callback to handle SNI              *
 826 *************************************************/
 827
 828 /* Called when acting as server during the TLS session setup if a Server Name
 829 Indication extension was sent by the client.
 830
 831 API documentation is OpenSSL s_server.c implementation.
 832
 833 Arguments:
 834   s               SSL* of the current session
 835   ad              unknown (part of OpenSSL API) (unused)
 836   arg             Callback of "our" registered data
 837
 838 Returns:          SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
 839 */
 840
 841 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 842 static int
 843 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
 844 {
 845 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 846 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
 847 int rc;
 848 int old_pool = store_pool;
 849
 850 if (!servername)
 851   return SSL_TLSEXT_ERR_OK;
 852
 853 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
 854     reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
 855
 856 /* Make the extension value available for expansion */
 857 store_pool = POOL_PERM;
 858 tls_in.sni = string_copy(US servername);
 859 store_pool = old_pool;
 860
 861 if (!reexpand_tls_files_for_sni)
 862   return SSL_TLSEXT_ERR_OK;
 863
 864 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
 865 not confident that memcpy wouldn't break some internal reference counting.
 866 Especially since there's a references struct member, which would be off. */
 867
 868 if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
 869   {
 870   ERR_error_string(ERR_get_error(), ssl_errstring);
 871   DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
 872   return SSL_TLSEXT_ERR_NOACK;
 873   }
 874
 875 /* Not sure how many of these are actually needed, since SSL object
 876 already exists.  Might even need this selfsame callback, for reneg? */
 877
 878 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
 879 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
 880 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
 881 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
 882 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
 883 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
 884 if (cbinfo->server_cipher_list)
 885   SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list);
 886 #ifndef DISABLE_OCSP
 887 if (cbinfo->u_ocsp.server.file)
 888   {
 889   SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
 890   SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
 891   }
 892 #endif
 893
 894 rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE, verify_callback_server);
 895 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
 896
 897 /* do this after setup_certs, because this can require the certs for verifying
 898 OCSP information. */
 899 rc = tls_expand_session_files(server_sni, cbinfo);
 900 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
 901
 902 if (!init_dh(server_sni, cbinfo->dhparam, NULL))
 903   return SSL_TLSEXT_ERR_NOACK;
 904
 905 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
 906 SSL_set_SSL_CTX(s, server_sni);
 907
 908 return SSL_TLSEXT_ERR_OK;
 909 }
 910 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
 911
 912
 913
 914
 915 #ifndef DISABLE_OCSP
 916
 917 /*************************************************
 918 *        Callback to handle OCSP Stapling        *
 919 *************************************************/
 920
 921 /* Called when acting as server during the TLS session setup if the client
 922 requests OCSP information with a Certificate Status Request.
 923
 924 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
 925 project.
 926
 927 */
 928
 929 static int
 930 tls_server_stapling_cb(SSL *s, void *arg)
 931 {
 932 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
 933 uschar *response_der;
 934 int response_der_len;
 935
 936 DEBUG(D_tls)
 937   debug_printf("Received TLS status request (OCSP stapling); %s response.",
 938     cbinfo->u_ocsp.server.response ? "have" : "lack");
 939
 940 tls_in.ocsp = OCSP_NOT_RESP;
 941 if (!cbinfo->u_ocsp.server.response)
 942   return SSL_TLSEXT_ERR_NOACK;
 943
 944 response_der = NULL;
 945 response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response,
 946                       &response_der);
 947 if (response_der_len <= 0)
 948   return SSL_TLSEXT_ERR_NOACK;
 949
 950 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
 951 tls_in.ocsp = OCSP_VFIED;
 952 return SSL_TLSEXT_ERR_OK;
 953 }
 954
 955
 956 static void
 957 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
 958 {
 959 BIO_printf(bp, "\t%s: ", str);
 960 ASN1_GENERALIZEDTIME_print(bp, time);
 961 BIO_puts(bp, "\n");
 962 }
 963
 964 static int
 965 tls_client_stapling_cb(SSL *s, void *arg)
 966 {
 967 tls_ext_ctx_cb * cbinfo = arg;
 968 const unsigned char * p;
 969 int len;
 970 OCSP_RESPONSE * rsp;
 971 OCSP_BASICRESP * bs;
 972 int i;
 973
 974 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
 975 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
 976 if(!p)
 977  {
 978   /* Expect this when we requested ocsp but got none */
 979   if (  cbinfo->u_ocsp.client.verify_required
 980      && log_extra_selector & LX_tls_cipher)
 981     log_write(0, LOG_MAIN, "Received TLS status callback, null content");
 982   else
 983     DEBUG(D_tls) debug_printf(" null\n");
 984   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
 985  }
 986
 987 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
 988  {
 989   tls_out.ocsp = OCSP_FAILED;
 990   if (log_extra_selector & LX_tls_cipher)
 991     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
 992   else
 993     DEBUG(D_tls) debug_printf(" parse error\n");
 994   return 0;
 995  }
 996
 997 if(!(bs = OCSP_response_get1_basic(rsp)))
 998   {
 999   tls_out.ocsp = OCSP_FAILED;
1000   if (log_extra_selector & LX_tls_cipher)
1001     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1002   else
1003     DEBUG(D_tls) debug_printf(" error parsing response\n");
1004   OCSP_RESPONSE_free(rsp);
1005   return 0;
1006   }
1007
1008 /* We'd check the nonce here if we'd put one in the request. */
1009 /* However that would defeat cacheability on the server so we don't. */
1010
1011 /* This section of code reworked from OpenSSL apps source;
1012    The OpenSSL Project retains copyright:
1013    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
1014 */
1015   {
1016     BIO * bp = NULL;
1017     int status, reason;
1018     ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1019
1020     DEBUG(D_tls) bp = BIO_new_fp(stderr, BIO_NOCLOSE);
1021
1022     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
1023
1024     /* Use the chain that verified the server cert to verify the stapled info */
1025     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1026
1027     if ((i = OCSP_basic_verify(bs, NULL,
1028               cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1029       {
1030       tls_out.ocsp = OCSP_FAILED;
1031       if (log_extra_selector & LX_tls_cipher)
1032         log_write(0, LOG_MAIN, "Received TLS cert status response, itself unverifiable");
1033       BIO_printf(bp, "OCSP response verify failure\n");
1034       ERR_print_errors(bp);
1035       i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1036       goto out;
1037       }
1038
1039     BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1040
1041       {
1042       STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1043       OCSP_SINGLERESP * single;
1044
1045       if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1046         {
1047         tls_out.ocsp = OCSP_FAILED;
1048         log_write(0, LOG_MAIN, "OCSP stapling "
1049             "with multiple responses not handled");
1050         i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1051         goto out;
1052         }
1053       single = OCSP_resp_get0(bs, 0);
1054       status = OCSP_single_get0_status(single, &reason, &rev,
1055                   &thisupd, &nextupd);
1056       }
1057
1058     DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1059     DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1060     if (!OCSP_check_validity(thisupd, nextupd,
1061           EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1062       {
1063       tls_out.ocsp = OCSP_FAILED;
1064       DEBUG(D_tls) ERR_print_errors(bp);
1065       log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1066       i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1067       }
1068     else
1069       {
1070       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1071                     OCSP_cert_status_str(status));
1072       switch(status)
1073         {
1074         case V_OCSP_CERTSTATUS_GOOD:
1075           tls_out.ocsp = OCSP_VFIED;
1076           i = 1;
1077           break;
1078         case V_OCSP_CERTSTATUS_REVOKED:
1079           tls_out.ocsp = OCSP_FAILED;
1080           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1081               reason != -1 ? "; reason: " : "",
1082               reason != -1 ? OCSP_crl_reason_str(reason) : "");
1083           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1084           i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1085           break;
1086         default:
1087           tls_out.ocsp = OCSP_FAILED;
1088           log_write(0, LOG_MAIN,
1089               "Server certificate status unknown, in OCSP stapling");
1090           i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1091           break;
1092         }
1093       }
1094   out:
1095     BIO_free(bp);
1096   }
1097
1098 OCSP_RESPONSE_free(rsp);
1099 return i;
1100 }
1101 #endif  /*!DISABLE_OCSP*/
1102
1103
1104 /*************************************************
1105 *            Initialize for TLS                  *
1106 *************************************************/
1107
1108 /* Called from both server and client code, to do preliminary initialization
1109 of the library.  We allocate and return a context structure.
1110
1111 Arguments:
1112   ctxp            returned SSL context
1113   host            connected host, if client; NULL if server
1114   dhparam         DH parameter file
1115   certificate     certificate file
1116   privatekey      private key
1117   ocsp_file       file of stapling info (server); flag for require ocsp (client)
1118   addr            address if client; NULL if server (for some randomness)
1119   cbp             place to put allocated callback context
1120
1121 Returns:          OK/DEFER/FAIL
1122 */
1123
1124 static int
1125 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1126   uschar *privatekey,
1127 #ifndef DISABLE_OCSP
1128   uschar *ocsp_file,
1129 #endif
1130   address_item *addr, tls_ext_ctx_cb ** cbp)
1131 {
1132 long init_options;
1133 int rc;
1134 BOOL okay;
1135 tls_ext_ctx_cb * cbinfo;
1136
1137 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1138 cbinfo->certificate = certificate;
1139 cbinfo->privatekey = privatekey;
1140 #ifndef DISABLE_OCSP
1141 if ((cbinfo->is_server = host==NULL))
1142   {
1143   cbinfo->u_ocsp.server.file = ocsp_file;
1144   cbinfo->u_ocsp.server.file_expanded = NULL;
1145   cbinfo->u_ocsp.server.response = NULL;
1146   }
1147 else
1148   cbinfo->u_ocsp.client.verify_store = NULL;
1149 #endif
1150 cbinfo->dhparam = dhparam;
1151 cbinfo->server_cipher_list = NULL;
1152 cbinfo->host = host;
1153 #ifdef EXPERIMENTAL_EVENT
1154 cbinfo->event_action = NULL;
1155 #endif
1156
1157 SSL_load_error_strings();          /* basic set up */
1158 OpenSSL_add_ssl_algorithms();
1159
1160 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
1161 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1162 list of available digests. */
1163 EVP_add_digest(EVP_sha256());
1164 #endif
1165
1166 /* Create a context.
1167 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1168 negotiation in the different methods; as far as I can tell, the only
1169 *_{server,client}_method which allows negotiation is SSLv23, which exists even
1170 when OpenSSL is built without SSLv2 support.
1171 By disabling with openssl_options, we can let admins re-enable with the
1172 existing knob. */
1173
1174 *ctxp = SSL_CTX_new((host == NULL)?
1175   SSLv23_server_method() : SSLv23_client_method());
1176
1177 if (*ctxp == NULL) return tls_error(US"SSL_CTX_new", host, NULL);
1178
1179 /* It turns out that we need to seed the random number generator this early in
1180 order to get the full complement of ciphers to work. It took me roughly a day
1181 of work to discover this by experiment.
1182
1183 On systems that have /dev/urandom, SSL may automatically seed itself from
1184 there. Otherwise, we have to make something up as best we can. Double check
1185 afterwards. */
1186
1187 if (!RAND_status())
1188   {
1189   randstuff r;
1190   gettimeofday(&r.tv, NULL);
1191   r.p = getpid();
1192
1193   RAND_seed((uschar *)(&r), sizeof(r));
1194   RAND_seed((uschar *)big_buffer, big_buffer_size);
1195   if (addr != NULL) RAND_seed((uschar *)addr, sizeof(addr));
1196
1197   if (!RAND_status())
1198     return tls_error(US"RAND_status", host,
1199       US"unable to seed random number generator");
1200   }
1201
1202 /* Set up the information callback, which outputs if debugging is at a suitable
1203 level. */
1204
1205 SSL_CTX_set_info_callback(*ctxp, (void (*)())info_callback);
1206
1207 /* Automatically re-try reads/writes after renegotiation. */
1208 (void) SSL_CTX_set_mode(*ctxp, SSL_MODE_AUTO_RETRY);
1209
1210 /* Apply administrator-supplied work-arounds.
1211 Historically we applied just one requested option,
1212 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1213 moved to an administrator-controlled list of options to specify and
1214 grandfathered in the first one as the default value for "openssl_options".
1215
1216 No OpenSSL version number checks: the options we accept depend upon the
1217 availability of the option value macros from OpenSSL.  */
1218
1219 okay = tls_openssl_options_parse(openssl_options, &init_options);
1220 if (!okay)
1221   return tls_error(US"openssl_options parsing failed", host, NULL);
1222
1223 if (init_options)
1224   {
1225   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
1226   if (!(SSL_CTX_set_options(*ctxp, init_options)))
1227     return tls_error(string_sprintf(
1228           "SSL_CTX_set_option(%#lx)", init_options), host, NULL);
1229   }
1230 else
1231   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
1232
1233 /* Initialize with DH parameters if supplied */
1234
1235 if (!init_dh(*ctxp, dhparam, host)) return DEFER;
1236
1237 /* Set up certificate and key (and perhaps OCSP info) */
1238
1239 rc = tls_expand_session_files(*ctxp, cbinfo);
1240 if (rc != OK) return rc;
1241
1242 /* If we need to handle SNI, do so */
1243 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1244 if (host == NULL)               /* server */
1245   {
1246 # ifndef DISABLE_OCSP
1247   /* We check u_ocsp.server.file, not server.response, because we care about if
1248   the option exists, not what the current expansion might be, as SNI might
1249   change the certificate and OCSP file in use between now and the time the
1250   callback is invoked. */
1251   if (cbinfo->u_ocsp.server.file)
1252     {
1253     SSL_CTX_set_tlsext_status_cb(server_ctx, tls_server_stapling_cb);
1254     SSL_CTX_set_tlsext_status_arg(server_ctx, cbinfo);
1255     }
1256 # endif
1257   /* We always do this, so that $tls_sni is available even if not used in
1258   tls_certificate */
1259   SSL_CTX_set_tlsext_servername_callback(*ctxp, tls_servername_cb);
1260   SSL_CTX_set_tlsext_servername_arg(*ctxp, cbinfo);
1261   }
1262 # ifndef DISABLE_OCSP
1263 else                    /* client */
1264   if(ocsp_file)         /* wanting stapling */
1265     {
1266     if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
1267       {
1268       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
1269       return FAIL;
1270       }
1271     SSL_CTX_set_tlsext_status_cb(*ctxp, tls_client_stapling_cb);
1272     SSL_CTX_set_tlsext_status_arg(*ctxp, cbinfo);
1273     }
1274 # endif
1275 #endif
1276
1277 #ifdef EXPERIMENTAL_CERTNAMES
1278 cbinfo->verify_cert_hostnames = NULL;
1279 #endif
1280
1281 /* Set up the RSA callback */
1282
1283 SSL_CTX_set_tmp_rsa_callback(*ctxp, rsa_callback);
1284
1285 /* Finally, set the timeout, and we are done */
1286
1287 SSL_CTX_set_timeout(*ctxp, ssl_session_timeout);
1288 DEBUG(D_tls) debug_printf("Initialized TLS\n");
1289
1290 *cbp = cbinfo;
1291
1292 return OK;
1293 }
1294
1295
1296
1297
1298 /*************************************************
1299 *           Get name of cipher in use            *
1300 *************************************************/
1301
1302 /*
1303 Argument:   pointer to an SSL structure for the connection
1304             buffer to use for answer
1305             size of buffer
1306             pointer to number of bits for cipher
1307 Returns:    nothing
1308 */
1309
1310 static void
1311 construct_cipher_name(SSL *ssl, uschar *cipherbuf, int bsize, int *bits)
1312 {
1313 /* With OpenSSL 1.0.0a, this needs to be const but the documentation doesn't
1314 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
1315 the accessor functions use const in the prototype. */
1316 const SSL_CIPHER *c;
1317 const uschar *ver;
1318
1319 ver = (const uschar *)SSL_get_version(ssl);
1320
1321 c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
1322 SSL_CIPHER_get_bits(c, bits);
1323
1324 string_format(cipherbuf, bsize, "%s:%s:%u", ver,
1325   SSL_CIPHER_get_name(c), *bits);
1326
1327 DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
1328 }
1329
1330
1331
1332
1333
1334 /*************************************************
1335 *        Set up for verifying certificates       *
1336 *************************************************/
1337
1338 /* Called by both client and server startup
1339
1340 Arguments:
1341   sctx          SSL_CTX* to initialise
1342   certs         certs file or NULL
1343   crl           CRL file or NULL
1344   host          NULL in a server; the remote host in a client
1345   optional      TRUE if called from a server for a host in tls_try_verify_hosts;
1346                 otherwise passed as FALSE
1347   cert_vfy_cb   Callback function for certificate verification
1348
1349 Returns:        OK/DEFER/FAIL
1350 */
1351
1352 static int
1353 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
1354     int (*cert_vfy_cb)(int, X509_STORE_CTX *) )
1355 {
1356 uschar *expcerts, *expcrl;
1357
1358 if (!expand_check(certs, US"tls_verify_certificates", &expcerts))
1359   return DEFER;
1360
1361 if (expcerts != NULL && *expcerts != '\0')
1362   {
1363   struct stat statbuf;
1364   if (!SSL_CTX_set_default_verify_paths(sctx))
1365     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL);
1366
1367   if (Ustat(expcerts, &statbuf) < 0)
1368     {
1369     log_write(0, LOG_MAIN|LOG_PANIC,
1370       "failed to stat %s for certificates", expcerts);
1371     return DEFER;
1372     }
1373   else
1374     {
1375     uschar *file, *dir;
1376     if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1377       { file = NULL; dir = expcerts; }
1378     else
1379       { file = expcerts; dir = NULL; }
1380
1381     /* If a certificate file is empty, the next function fails with an
1382     unhelpful error message. If we skip it, we get the correct behaviour (no
1383     certificates are recognized, but the error message is still misleading (it
1384     says no certificate was supplied.) But this is better. */
1385
1386     if ((file == NULL || statbuf.st_size > 0) &&
1387           !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
1388       return tls_error(US"SSL_CTX_load_verify_locations", host, NULL);
1389
1390     /* Load the list of CAs for which we will accept certs, for sending
1391     to the client.  This is only for the one-file tls_verify_certificates
1392     variant.
1393     If a list isn't loaded into the server, but
1394     some verify locations are set, the server end appears to make
1395     a wildcard reqest for client certs.
1396     Meanwhile, the client library as deafult behaviour *ignores* the list
1397     we send over the wire - see man SSL_CTX_set_client_cert_cb.
1398     Because of this, and that the dir variant is likely only used for
1399     the public-CA bundle (not for a private CA), not worth fixing.
1400     */
1401     if (file != NULL)
1402       {
1403       STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
1404 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
1405                                   sk_X509_NAME_num(names));
1406       SSL_CTX_set_client_CA_list(sctx, names);
1407       }
1408     }
1409
1410   /* Handle a certificate revocation list. */
1411
1412   #if OPENSSL_VERSION_NUMBER > 0x00907000L
1413
1414   /* This bit of code is now the version supplied by Lars Mainka. (I have
1415    * merely reformatted it into the Exim code style.)
1416
1417    * "From here I changed the code to add support for multiple crl's
1418    * in pem format in one file or to support hashed directory entries in
1419    * pem format instead of a file. This method now uses the library function
1420    * X509_STORE_load_locations to add the CRL location to the SSL context.
1421    * OpenSSL will then handle the verify against CA certs and CRLs by
1422    * itself in the verify callback." */
1423
1424   if (!expand_check(crl, US"tls_crl", &expcrl)) return DEFER;
1425   if (expcrl != NULL && *expcrl != 0)
1426     {
1427     struct stat statbufcrl;
1428     if (Ustat(expcrl, &statbufcrl) < 0)
1429       {
1430       log_write(0, LOG_MAIN|LOG_PANIC,
1431         "failed to stat %s for certificates revocation lists", expcrl);
1432       return DEFER;
1433       }
1434     else
1435       {
1436       /* is it a file or directory? */
1437       uschar *file, *dir;
1438       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
1439       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
1440         {
1441         file = NULL;
1442         dir = expcrl;
1443         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
1444         }
1445       else
1446         {
1447         file = expcrl;
1448         dir = NULL;
1449         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
1450         }
1451       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
1452         return tls_error(US"X509_STORE_load_locations", host, NULL);
1453
1454       /* setting the flags to check against the complete crl chain */
1455
1456       X509_STORE_set_flags(cvstore,
1457         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
1458       }
1459     }
1460
1461   #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
1462
1463   /* If verification is optional, don't fail if no certificate */
1464
1465   SSL_CTX_set_verify(sctx,
1466     SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
1467     cert_vfy_cb);
1468   }
1469
1470 return OK;
1471 }
1472
1473
1474
1475 /*************************************************
1476 *       Start a TLS session in a server          *
1477 *************************************************/
1478
1479 /* This is called when Exim is running as a server, after having received
1480 the STARTTLS command. It must respond to that command, and then negotiate
1481 a TLS session.
1482
1483 Arguments:
1484   require_ciphers   allowed ciphers
1485
1486 Returns:            OK on success
1487                     DEFER for errors before the start of the negotiation
1488                     FAIL for errors during the negotation; the server can't
1489                       continue running.
1490 */
1491
1492 int
1493 tls_server_start(const uschar *require_ciphers)
1494 {
1495 int rc;
1496 uschar *expciphers;
1497 tls_ext_ctx_cb *cbinfo;
1498 static uschar cipherbuf[256];
1499
1500 /* Check for previous activation */
1501
1502 if (tls_in.active >= 0)
1503   {
1504   tls_error(US"STARTTLS received after TLS started", NULL, US"");
1505   smtp_printf("554 Already in TLS\r\n");
1506   return FAIL;
1507   }
1508
1509 /* Initialize the SSL library. If it fails, it will already have logged
1510 the error. */
1511
1512 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
1513 #ifndef DISABLE_OCSP
1514     tls_ocsp_file,
1515 #endif
1516     NULL, &server_static_cbinfo);
1517 if (rc != OK) return rc;
1518 cbinfo = server_static_cbinfo;
1519
1520 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers))
1521   return FAIL;
1522
1523 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1524 were historically separated by underscores. So that I can use either form in my
1525 tests, and also for general convenience, we turn underscores into hyphens here.
1526 */
1527
1528 if (expciphers != NULL)
1529   {
1530   uschar *s = expciphers;
1531   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1532   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
1533   if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
1534     return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL);
1535   cbinfo->server_cipher_list = expciphers;
1536   }
1537
1538 /* If this is a host for which certificate verification is mandatory or
1539 optional, set up appropriately. */
1540
1541 tls_in.certificate_verified = FALSE;
1542 #ifdef EXPERIMENTAL_DANE
1543 tls_in.dane_verified = FALSE;
1544 #endif
1545 server_verify_callback_called = FALSE;
1546
1547 if (verify_check_host(&tls_verify_hosts) == OK)
1548   {
1549   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
1550                         FALSE, verify_callback_server);
1551   if (rc != OK) return rc;
1552   server_verify_optional = FALSE;
1553   }
1554 else if (verify_check_host(&tls_try_verify_hosts) == OK)
1555   {
1556   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
1557                         TRUE, verify_callback_server);
1558   if (rc != OK) return rc;
1559   server_verify_optional = TRUE;
1560   }
1561
1562 /* Prepare for new connection */
1563
1564 if ((server_ssl = SSL_new(server_ctx)) == NULL) return tls_error(US"SSL_new", NULL, NULL);
1565
1566 /* Warning: we used to SSL_clear(ssl) here, it was removed.
1567  *
1568  * With the SSL_clear(), we get strange interoperability bugs with
1569  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
1570  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
1571  *
1572  * The SSL_clear() call is to let an existing SSL* be reused, typically after
1573  * session shutdown.  In this case, we have a brand new object and there's no
1574  * obvious reason to immediately clear it.  I'm guessing that this was
1575  * originally added because of incomplete initialisation which the clear fixed,
1576  * in some historic release.
1577  */
1578
1579 /* Set context and tell client to go ahead, except in the case of TLS startup
1580 on connection, where outputting anything now upsets the clients and tends to
1581 make them disconnect. We need to have an explicit fflush() here, to force out
1582 the response. Other smtp_printf() calls do not need it, because in non-TLS
1583 mode, the fflush() happens when smtp_getc() is called. */
1584
1585 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
1586 if (!tls_in.on_connect)
1587   {
1588   smtp_printf("220 TLS go ahead\r\n");
1589   fflush(smtp_out);
1590   }
1591
1592 /* Now negotiate the TLS session. We put our own timer on it, since it seems
1593 that the OpenSSL library doesn't. */
1594
1595 SSL_set_wfd(server_ssl, fileno(smtp_out));
1596 SSL_set_rfd(server_ssl, fileno(smtp_in));
1597 SSL_set_accept_state(server_ssl);
1598
1599 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
1600
1601 sigalrm_seen = FALSE;
1602 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1603 rc = SSL_accept(server_ssl);
1604 alarm(0);
1605
1606 if (rc <= 0)
1607   {
1608   tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL);
1609   if (ERR_get_error() == 0)
1610     log_write(0, LOG_MAIN,
1611         "TLS client disconnected cleanly (rejected our certificate?)");
1612   return FAIL;
1613   }
1614
1615 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
1616
1617 /* TLS has been set up. Adjust the input functions to read via TLS,
1618 and initialize things. */
1619
1620 construct_cipher_name(server_ssl, cipherbuf, sizeof(cipherbuf), &tls_in.bits);
1621 tls_in.cipher = cipherbuf;
1622
1623 DEBUG(D_tls)
1624   {
1625   uschar buf[2048];
1626   if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)) != NULL)
1627     debug_printf("Shared ciphers: %s\n", buf);
1628   }
1629
1630 /* Record the certificate we presented */
1631   {
1632   X509 * crt = SSL_get_certificate(server_ssl);
1633   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
1634   }
1635
1636 /* Only used by the server-side tls (tls_in), including tls_getc.
1637    Client-side (tls_out) reads (seem to?) go via
1638    smtp_read_response()/ip_recv().
1639    Hence no need to duplicate for _in and _out.
1640  */
1641 ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
1642 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
1643 ssl_xfer_eof = ssl_xfer_error = 0;
1644
1645 receive_getc = tls_getc;
1646 receive_ungetc = tls_ungetc;
1647 receive_feof = tls_feof;
1648 receive_ferror = tls_ferror;
1649 receive_smtp_buffered = tls_smtp_buffered;
1650
1651 tls_in.active = fileno(smtp_out);
1652 return OK;
1653 }
1654
1655
1656
1657
1658 static int
1659 tls_client_basic_ctx_init(SSL_CTX * ctx,
1660     host_item * host, smtp_transport_options_block * ob
1661 #ifdef EXPERIMENTAL_CERTNAMES
1662     , tls_ext_ctx_cb * cbinfo
1663 #endif
1664                           )
1665 {
1666 int rc;
1667 /* stick to the old behaviour for compatibility if tls_verify_certificates is
1668    set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
1669    the specified host patterns if one of them is defined */
1670
1671 if ((!ob->tls_verify_hosts && !ob->tls_try_verify_hosts) ||
1672     (verify_check_host(&ob->tls_verify_hosts) == OK))
1673   {
1674   if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
1675         ob->tls_crl, host, FALSE, verify_callback_client)) != OK)
1676     return rc;
1677   client_verify_optional = FALSE;
1678
1679 #ifdef EXPERIMENTAL_CERTNAMES
1680   if (ob->tls_verify_cert_hostnames)
1681     {
1682     if (!expand_check(ob->tls_verify_cert_hostnames,
1683                       US"tls_verify_cert_hostnames",
1684                       &cbinfo->verify_cert_hostnames))
1685       return FAIL;
1686     if (cbinfo->verify_cert_hostnames)
1687       DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
1688                       cbinfo->verify_cert_hostnames);
1689     }
1690 #endif
1691   }
1692 else if (verify_check_host(&ob->tls_try_verify_hosts) == OK)
1693   {
1694   if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
1695         ob->tls_crl, host, TRUE, verify_callback_client)) != OK)
1696     return rc;
1697   client_verify_optional = TRUE;
1698   }
1699
1700 return OK;
1701 }
1702
1703
1704 #ifdef EXPERIMENTAL_DANE
1705 static int
1706 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa)
1707 {
1708 dns_record * rr;
1709 dns_scan dnss;
1710 const char * hostnames[2] = { CS host->name, NULL };
1711 int found = 0;
1712
1713 if (DANESSL_init(ssl, NULL, hostnames) != 1)
1714   return tls_error(US"hostnames load", host, NULL);
1715
1716 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1717      rr;
1718      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
1719     ) if (rr->type == T_TLSA)
1720   {
1721   uschar * p = rr->data;
1722   uint8_t usage, selector, mtype;
1723   const char * mdname;
1724
1725   usage = *p++;
1726
1727   /* Only DANE-TA(2) and DANE-EE(3) are supported */
1728   if (usage != 2 && usage != 3) continue;
1729
1730   selector = *p++;
1731   mtype = *p++;
1732
1733   switch (mtype)
1734     {
1735     default: continue;  /* Only match-types 0, 1, 2 are supported */
1736     case 0:  mdname = NULL; break;
1737     case 1:  mdname = "sha256"; break;
1738     case 2:  mdname = "sha512"; break;
1739     }
1740
1741   found++;
1742   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
1743     {
1744     default:
1745     case 0:     /* action not taken */
1746       return tls_error(US"tlsa load", host, NULL);
1747     case 1:     break;
1748     }
1749
1750   tls_out.tlsa_usage |= 1<<usage;
1751   }
1752
1753 if (found)
1754   return OK;
1755
1756 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
1757 return FAIL;
1758 }
1759 #endif  /*EXPERIMENTAL_DANE*/
1760
1761
1762
1763 /*************************************************
1764 *    Start a TLS session in a client             *
1765 *************************************************/
1766
1767 /* Called from the smtp transport after STARTTLS has been accepted.
1768
1769 Argument:
1770   fd               the fd of the connection
1771   host             connected host (for messages)
1772   addr             the first address
1773   tb               transport (always smtp)
1774   tlsa_dnsa        tlsa lookup, if DANE, else null
1775
1776 Returns:           OK on success
1777                    FAIL otherwise - note that tls_error() will not give DEFER
1778                      because this is not a server
1779 */
1780
1781 int
1782 tls_client_start(int fd, host_item *host, address_item *addr,
1783   transport_instance *tb
1784 #ifdef EXPERIMENTAL_DANE
1785   , dns_answer * tlsa_dnsa
1786 #endif
1787   )
1788 {
1789 smtp_transport_options_block * ob =
1790   (smtp_transport_options_block *)tb->options_block;
1791 static uschar txt[256];
1792 uschar * expciphers;
1793 X509 * server_cert;
1794 int rc;
1795 static uschar cipherbuf[256];
1796
1797 #ifndef DISABLE_OCSP
1798 BOOL request_ocsp = FALSE;
1799 BOOL require_ocsp = FALSE;
1800 #endif
1801
1802 #ifdef EXPERIMENTAL_DANE
1803 tls_out.tlsa_usage = 0;
1804 #endif
1805
1806 #ifndef DISABLE_OCSP
1807   {
1808 # ifdef EXPERIMENTAL_DANE
1809   if (  tlsa_dnsa
1810      && ob->hosts_request_ocsp[0] == '*'
1811      && ob->hosts_request_ocsp[1] == '\0'
1812      )
1813     {
1814     /* Unchanged from default.  Use a safer one under DANE */
1815     request_ocsp = TRUE;
1816     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
1817                                       "   {= {4}{$tls_out_tlsa_usage}} } "
1818                                  " {*}{}}";
1819     }
1820 # endif
1821
1822   if ((require_ocsp = verify_check_this_host(&ob->hosts_require_ocsp,
1823     NULL, host->name, host->address, NULL) == OK))
1824     request_ocsp = TRUE;
1825   else
1826 # ifdef EXPERIMENTAL_DANE
1827     if (!request_ocsp)
1828 # endif
1829       request_ocsp = verify_check_this_host(&ob->hosts_request_ocsp,
1830           NULL, host->name, host->address, NULL) == OK;
1831   }
1832 #endif
1833
1834 rc = tls_init(&client_ctx, host, NULL,
1835     ob->tls_certificate, ob->tls_privatekey,
1836 #ifndef DISABLE_OCSP
1837     (void *)(long)request_ocsp,
1838 #endif
1839     addr, &client_static_cbinfo);
1840 if (rc != OK) return rc;
1841
1842 tls_out.certificate_verified = FALSE;
1843 client_verify_callback_called = FALSE;
1844
1845 if (!expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
1846     &expciphers))
1847   return FAIL;
1848
1849 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1850 are separated by underscores. So that I can use either form in my tests, and
1851 also for general convenience, we turn underscores into hyphens here. */
1852
1853 if (expciphers != NULL)
1854   {
1855   uschar *s = expciphers;
1856   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1857   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
1858   if (!SSL_CTX_set_cipher_list(client_ctx, CS expciphers))
1859     return tls_error(US"SSL_CTX_set_cipher_list", host, NULL);
1860   }
1861
1862 #ifdef EXPERIMENTAL_DANE
1863 if (tlsa_dnsa)
1864   {
1865   SSL_CTX_set_verify(client_ctx, SSL_VERIFY_PEER, verify_callback_client_dane);
1866
1867   if (!DANESSL_library_init())
1868     return tls_error(US"library init", host, NULL);
1869   if (DANESSL_CTX_init(client_ctx) <= 0)
1870     return tls_error(US"context init", host, NULL);
1871   }
1872 else
1873
1874 #endif
1875
1876   if ((rc = tls_client_basic_ctx_init(client_ctx, host, ob
1877 #ifdef EXPERIMENTAL_CERTNAMES
1878                                 , client_static_cbinfo
1879 #endif
1880                                 )) != OK)
1881     return rc;
1882
1883 if ((client_ssl = SSL_new(client_ctx)) == NULL)
1884   return tls_error(US"SSL_new", host, NULL);
1885 SSL_set_session_id_context(client_ssl, sid_ctx, Ustrlen(sid_ctx));
1886 SSL_set_fd(client_ssl, fd);
1887 SSL_set_connect_state(client_ssl);
1888
1889 if (ob->tls_sni)
1890   {
1891   if (!expand_check(ob->tls_sni, US"tls_sni", &tls_out.sni))
1892     return FAIL;
1893   if (tls_out.sni == NULL)
1894     {
1895     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
1896     }
1897   else if (!Ustrlen(tls_out.sni))
1898     tls_out.sni = NULL;
1899   else
1900     {
1901 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1902     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tls_out.sni);
1903     SSL_set_tlsext_host_name(client_ssl, tls_out.sni);
1904 #else
1905     DEBUG(D_tls)
1906       debug_printf("OpenSSL at build-time lacked SNI support, ignoring \"%s\"\n",
1907           tls_out.sni);
1908 #endif
1909     }
1910   }
1911
1912 #ifdef EXPERIMENTAL_DANE
1913 if (tlsa_dnsa)
1914   if ((rc = dane_tlsa_load(client_ssl, host, tlsa_dnsa)) != OK)
1915     return rc;
1916 #endif
1917
1918 #ifndef DISABLE_OCSP
1919 /* Request certificate status at connection-time.  If the server
1920 does OCSP stapling we will get the callback (set in tls_init()) */
1921 # ifdef EXPERIMENTAL_DANE
1922 if (request_ocsp)
1923   {
1924   const uschar * s;
1925   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
1926      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
1927      )
1928     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
1929         this means we avoid the OCSP request, we wasted the setup
1930         cost in tls_init(). */
1931     require_ocsp = verify_check_this_host(&ob->hosts_require_ocsp,
1932       NULL, host->name, host->address, NULL) == OK;
1933     request_ocsp = require_ocsp ? TRUE
1934       : verify_check_this_host(&ob->hosts_request_ocsp,
1935           NULL, host->name, host->address, NULL) == OK;
1936     }
1937   }
1938 # endif
1939
1940 if (request_ocsp)
1941   {
1942   SSL_set_tlsext_status_type(client_ssl, TLSEXT_STATUSTYPE_ocsp);
1943   client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
1944   tls_out.ocsp = OCSP_NOT_RESP;
1945   }
1946 #endif
1947
1948 #ifdef EXPERIMENTAL_EVENT
1949 client_static_cbinfo->event_action = tb->event_action;
1950 #endif
1951
1952 /* There doesn't seem to be a built-in timeout on connection. */
1953
1954 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
1955 sigalrm_seen = FALSE;
1956 alarm(ob->command_timeout);
1957 rc = SSL_connect(client_ssl);
1958 alarm(0);
1959
1960 #ifdef EXPERIMENTAL_DANE
1961 if (tlsa_dnsa)
1962   DANESSL_cleanup(client_ssl);
1963 #endif
1964
1965 if (rc <= 0)
1966   return tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL);
1967
1968 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
1969
1970 /* Beware anonymous ciphers which lead to server_cert being NULL */
1971 /*XXX server_cert is never freed... use X509_free() */
1972 server_cert = SSL_get_peer_certificate (client_ssl);
1973 if (server_cert)
1974   {
1975   tls_out.peerdn = US X509_NAME_oneline(X509_get_subject_name(server_cert),
1976     CS txt, sizeof(txt));
1977   tls_out.peerdn = txt;         /*XXX a static buffer... */
1978   }
1979 else
1980   tls_out.peerdn = NULL;
1981
1982 construct_cipher_name(client_ssl, cipherbuf, sizeof(cipherbuf), &tls_out.bits);
1983 tls_out.cipher = cipherbuf;
1984
1985 /* Record the certificate we presented */
1986   {
1987   X509 * crt = SSL_get_certificate(client_ssl);
1988   tls_out.ourcert = crt ? X509_dup(crt) : NULL;
1989   }
1990
1991 tls_out.active = fd;
1992 return OK;
1993 }
1994
1995
1996
1997
1998
1999 /*************************************************
2000 *            TLS version of getc                 *
2001 *************************************************/
2002
2003 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
2004 it refills the buffer via the SSL reading function.
2005
2006 Arguments:  none
2007 Returns:    the next character or EOF
2008
2009 Only used by the server-side TLS.
2010 */
2011
2012 int
2013 tls_getc(void)
2014 {
2015 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2016   {
2017   int error;
2018   int inbytes;
2019
2020   DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
2021     ssl_xfer_buffer, ssl_xfer_buffer_size);
2022
2023   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2024   inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer, ssl_xfer_buffer_size);
2025   error = SSL_get_error(server_ssl, inbytes);
2026   alarm(0);
2027
2028   /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
2029   closed down, not that the socket itself has been closed down. Revert to
2030   non-SSL handling. */
2031
2032   if (error == SSL_ERROR_ZERO_RETURN)
2033     {
2034     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2035
2036     receive_getc = smtp_getc;
2037     receive_ungetc = smtp_ungetc;
2038     receive_feof = smtp_feof;
2039     receive_ferror = smtp_ferror;
2040     receive_smtp_buffered = smtp_buffered;
2041
2042     SSL_free(server_ssl);
2043     server_ssl = NULL;
2044     tls_in.active = -1;
2045     tls_in.bits = 0;
2046     tls_in.cipher = NULL;
2047     tls_in.peerdn = NULL;
2048     tls_in.sni = NULL;
2049
2050     return smtp_getc();
2051     }
2052
2053   /* Handle genuine errors */
2054
2055   else if (error == SSL_ERROR_SSL)
2056     {
2057     ERR_error_string(ERR_get_error(), ssl_errstring);
2058     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
2059     ssl_xfer_error = 1;
2060     return EOF;
2061     }
2062
2063   else if (error != SSL_ERROR_NONE)
2064     {
2065     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
2066     ssl_xfer_error = 1;
2067     return EOF;
2068     }
2069
2070 #ifndef DISABLE_DKIM
2071   dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
2072 #endif
2073   ssl_xfer_buffer_hwm = inbytes;
2074   ssl_xfer_buffer_lwm = 0;
2075   }
2076
2077 /* Something in the buffer; return next uschar */
2078
2079 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
2080 }
2081
2082
2083
2084 /*************************************************
2085 *          Read bytes from TLS channel           *
2086 *************************************************/
2087
2088 /*
2089 Arguments:
2090   buff      buffer of data
2091   len       size of buffer
2092
2093 Returns:    the number of bytes read
2094             -1 after a failed read
2095
2096 Only used by the client-side TLS.
2097 */
2098
2099 int
2100 tls_read(BOOL is_server, uschar *buff, size_t len)
2101 {
2102 SSL *ssl = is_server ? server_ssl : client_ssl;
2103 int inbytes;
2104 int error;
2105
2106 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
2107   buff, (unsigned int)len);
2108
2109 inbytes = SSL_read(ssl, CS buff, len);
2110 error = SSL_get_error(ssl, inbytes);
2111
2112 if (error == SSL_ERROR_ZERO_RETURN)
2113   {
2114   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2115   return -1;
2116   }
2117 else if (error != SSL_ERROR_NONE)
2118   {
2119   return -1;
2120   }
2121
2122 return inbytes;
2123 }
2124
2125
2126
2127
2128
2129 /*************************************************
2130 *         Write bytes down TLS channel           *
2131 *************************************************/
2132
2133 /*
2134 Arguments:
2135   is_server channel specifier
2136   buff      buffer of data
2137   len       number of bytes
2138
2139 Returns:    the number of bytes after a successful write,
2140             -1 after a failed write
2141
2142 Used by both server-side and client-side TLS.
2143 */
2144
2145 int
2146 tls_write(BOOL is_server, const uschar *buff, size_t len)
2147 {
2148 int outbytes;
2149 int error;
2150 int left = len;
2151 SSL *ssl = is_server ? server_ssl : client_ssl;
2152
2153 DEBUG(D_tls) debug_printf("tls_do_write(%p, %d)\n", buff, left);
2154 while (left > 0)
2155   {
2156   DEBUG(D_tls) debug_printf("SSL_write(SSL, %p, %d)\n", buff, left);
2157   outbytes = SSL_write(ssl, CS buff, left);
2158   error = SSL_get_error(ssl, outbytes);
2159   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
2160   switch (error)
2161     {
2162     case SSL_ERROR_SSL:
2163     ERR_error_string(ERR_get_error(), ssl_errstring);
2164     log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
2165     return -1;
2166
2167     case SSL_ERROR_NONE:
2168     left -= outbytes;
2169     buff += outbytes;
2170     break;
2171
2172     case SSL_ERROR_ZERO_RETURN:
2173     log_write(0, LOG_MAIN, "SSL channel closed on write");
2174     return -1;
2175
2176     case SSL_ERROR_SYSCALL:
2177     log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
2178       sender_fullhost ? sender_fullhost : US"<unknown>",
2179       strerror(errno));
2180
2181     default:
2182     log_write(0, LOG_MAIN, "SSL_write error %d", error);
2183     return -1;
2184     }
2185   }
2186 return len;
2187 }
2188
2189
2190
2191 /*************************************************
2192 *         Close down a TLS session               *
2193 *************************************************/
2194
2195 /* This is also called from within a delivery subprocess forked from the
2196 daemon, to shut down the TLS library, without actually doing a shutdown (which
2197 would tamper with the SSL session in the parent process).
2198
2199 Arguments:   TRUE if SSL_shutdown is to be called
2200 Returns:     nothing
2201
2202 Used by both server-side and client-side TLS.
2203 */
2204
2205 void
2206 tls_close(BOOL is_server, BOOL shutdown)
2207 {
2208 SSL **sslp = is_server ? &server_ssl : &client_ssl;
2209 int *fdp = is_server ? &tls_in.active : &tls_out.active;
2210
2211 if (*fdp < 0) return;  /* TLS was not active */
2212
2213 if (shutdown)
2214   {
2215   DEBUG(D_tls) debug_printf("tls_close(): shutting down SSL\n");
2216   SSL_shutdown(*sslp);
2217   }
2218
2219 SSL_free(*sslp);
2220 *sslp = NULL;
2221
2222 *fdp = -1;
2223 }
2224
2225
2226
2227
2228 /*************************************************
2229 *  Let tls_require_ciphers be checked at startup *
2230 *************************************************/
2231
2232 /* The tls_require_ciphers option, if set, must be something which the
2233 library can parse.
2234
2235 Returns:     NULL on success, or error message
2236 */
2237
2238 uschar *
2239 tls_validate_require_cipher(void)
2240 {
2241 SSL_CTX *ctx;
2242 uschar *s, *expciphers, *err;
2243
2244 /* this duplicates from tls_init(), we need a better "init just global
2245 state, for no specific purpose" singleton function of our own */
2246
2247 SSL_load_error_strings();
2248 OpenSSL_add_ssl_algorithms();
2249 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
2250 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
2251 list of available digests. */
2252 EVP_add_digest(EVP_sha256());
2253 #endif
2254
2255 if (!(tls_require_ciphers && *tls_require_ciphers))
2256   return NULL;
2257
2258 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers))
2259   return US"failed to expand tls_require_ciphers";
2260
2261 if (!(expciphers && *expciphers))
2262   return NULL;
2263
2264 /* normalisation ripped from above */
2265 s = expciphers;
2266 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2267
2268 err = NULL;
2269
2270 ctx = SSL_CTX_new(SSLv23_server_method());
2271 if (!ctx)
2272   {
2273   ERR_error_string(ERR_get_error(), ssl_errstring);
2274   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
2275   }
2276
2277 DEBUG(D_tls)
2278   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
2279
2280 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
2281   {
2282   ERR_error_string(ERR_get_error(), ssl_errstring);
2283   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed", expciphers);
2284   }
2285
2286 SSL_CTX_free(ctx);
2287
2288 return err;
2289 }
2290
2291
2292
2293
2294 /*************************************************
2295 *         Report the library versions.           *
2296 *************************************************/
2297
2298 /* There have historically been some issues with binary compatibility in
2299 OpenSSL libraries; if Exim (like many other applications) is built against
2300 one version of OpenSSL but the run-time linker picks up another version,
2301 it can result in serious failures, including crashing with a SIGSEGV.  So
2302 report the version found by the compiler and the run-time version.
2303
2304 Note: some OS vendors backport security fixes without changing the version
2305 number/string, and the version date remains unchanged.  The _build_ date
2306 will change, so we can more usefully assist with version diagnosis by also
2307 reporting the build date.
2308
2309 Arguments:   a FILE* to print the results to
2310 Returns:     nothing
2311 */
2312
2313 void
2314 tls_version_report(FILE *f)
2315 {
2316 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
2317            "                          Runtime: %s\n"
2318            "                                 : %s\n",
2319            OPENSSL_VERSION_TEXT,
2320            SSLeay_version(SSLEAY_VERSION),
2321            SSLeay_version(SSLEAY_BUILT_ON));
2322 /* third line is 38 characters for the %s and the line is 73 chars long;
2323 the OpenSSL output includes a "built on: " prefix already. */
2324 }
2325
2326
2327
2328
2329 /*************************************************
2330 *            Random number generation            *
2331 *************************************************/
2332
2333 /* Pseudo-random number generation.  The result is not expected to be
2334 cryptographically strong but not so weak that someone will shoot themselves
2335 in the foot using it as a nonce in input in some email header scheme or
2336 whatever weirdness they'll twist this into.  The result should handle fork()
2337 and avoid repeating sequences.  OpenSSL handles that for us.
2338
2339 Arguments:
2340   max       range maximum
2341 Returns     a random number in range [0, max-1]
2342 */
2343
2344 int
2345 vaguely_random_number(int max)
2346 {
2347 unsigned int r;
2348 int i, needed_len;
2349 static pid_t pidlast = 0;
2350 pid_t pidnow;
2351 uschar *p;
2352 uschar smallbuf[sizeof(r)];
2353
2354 if (max <= 1)
2355   return 0;
2356
2357 pidnow = getpid();
2358 if (pidnow != pidlast)
2359   {
2360   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
2361   is unique for each thread", this doesn't apparently apply across processes,
2362   so our own warning from vaguely_random_number_fallback() applies here too.
2363   Fix per PostgreSQL. */
2364   if (pidlast != 0)
2365     RAND_cleanup();
2366   pidlast = pidnow;
2367   }
2368
2369 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
2370 if (!RAND_status())
2371   {
2372   randstuff r;
2373   gettimeofday(&r.tv, NULL);
2374   r.p = getpid();
2375
2376   RAND_seed((uschar *)(&r), sizeof(r));
2377   }
2378 /* We're after pseudo-random, not random; if we still don't have enough data
2379 in the internal PRNG then our options are limited.  We could sleep and hope
2380 for entropy to come along (prayer technique) but if the system is so depleted
2381 in the first place then something is likely to just keep taking it.  Instead,
2382 we'll just take whatever little bit of pseudo-random we can still manage to
2383 get. */
2384
2385 needed_len = sizeof(r);
2386 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
2387 asked for a number less than 10. */
2388 for (r = max, i = 0; r; ++i)
2389   r >>= 1;
2390 i = (i + 7) / 8;
2391 if (i < needed_len)
2392   needed_len = i;
2393
2394 /* We do not care if crypto-strong */
2395 i = RAND_pseudo_bytes(smallbuf, needed_len);
2396 if (i < 0)
2397   {
2398   DEBUG(D_all)
2399     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
2400   return vaguely_random_number_fallback(max);
2401   }
2402
2403 r = 0;
2404 for (p = smallbuf; needed_len; --needed_len, ++p)
2405   {
2406   r *= 256;
2407   r += *p;
2408   }
2409
2410 /* We don't particularly care about weighted results; if someone wants
2411 smooth distribution and cares enough then they should submit a patch then. */
2412 return r % max;
2413 }
2414
2415
2416
2417
2418 /*************************************************
2419 *        OpenSSL option parse                    *
2420 *************************************************/
2421
2422 /* Parse one option for tls_openssl_options_parse below
2423
2424 Arguments:
2425   name    one option name
2426   value   place to store a value for it
2427 Returns   success or failure in parsing
2428 */
2429
2430 struct exim_openssl_option {
2431   uschar *name;
2432   long    value;
2433 };
2434 /* We could use a macro to expand, but we need the ifdef and not all the
2435 options document which version they were introduced in.  Policylet: include
2436 all options unless explicitly for DTLS, let the administrator choose which
2437 to apply.
2438
2439 This list is current as of:
2440   ==>  1.0.1b  <==
2441 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
2442 */
2443 static struct exim_openssl_option exim_openssl_options[] = {
2444 /* KEEP SORTED ALPHABETICALLY! */
2445 #ifdef SSL_OP_ALL
2446   { US"all", SSL_OP_ALL },
2447 #endif
2448 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
2449   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
2450 #endif
2451 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
2452   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
2453 #endif
2454 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
2455   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
2456 #endif
2457 #ifdef SSL_OP_EPHEMERAL_RSA
2458   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
2459 #endif
2460 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
2461   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
2462 #endif
2463 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
2464   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
2465 #endif
2466 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
2467   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
2468 #endif
2469 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
2470   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
2471 #endif
2472 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
2473   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
2474 #endif
2475 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
2476   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
2477 #endif
2478 #ifdef SSL_OP_NO_COMPRESSION
2479   { US"no_compression", SSL_OP_NO_COMPRESSION },
2480 #endif
2481 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
2482   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
2483 #endif
2484 #ifdef SSL_OP_NO_SSLv2
2485   { US"no_sslv2", SSL_OP_NO_SSLv2 },
2486 #endif
2487 #ifdef SSL_OP_NO_SSLv3
2488   { US"no_sslv3", SSL_OP_NO_SSLv3 },
2489 #endif
2490 #ifdef SSL_OP_NO_TICKET
2491   { US"no_ticket", SSL_OP_NO_TICKET },
2492 #endif
2493 #ifdef SSL_OP_NO_TLSv1
2494   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
2495 #endif
2496 #ifdef SSL_OP_NO_TLSv1_1
2497 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
2498   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
2499 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
2500 #else
2501   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
2502 #endif
2503 #endif
2504 #ifdef SSL_OP_NO_TLSv1_2
2505   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
2506 #endif
2507 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
2508   { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
2509 #endif
2510 #ifdef SSL_OP_SINGLE_DH_USE
2511   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
2512 #endif
2513 #ifdef SSL_OP_SINGLE_ECDH_USE
2514   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
2515 #endif
2516 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
2517   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
2518 #endif
2519 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
2520   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
2521 #endif
2522 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
2523   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
2524 #endif
2525 #ifdef SSL_OP_TLS_D5_BUG
2526   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
2527 #endif
2528 #ifdef SSL_OP_TLS_ROLLBACK_BUG
2529   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
2530 #endif
2531 };
2532 static int exim_openssl_options_size =
2533   sizeof(exim_openssl_options)/sizeof(struct exim_openssl_option);
2534
2535
2536 static BOOL
2537 tls_openssl_one_option_parse(uschar *name, long *value)
2538 {
2539 int first = 0;
2540 int last = exim_openssl_options_size;
2541 while (last > first)
2542   {
2543   int middle = (first + last)/2;
2544   int c = Ustrcmp(name, exim_openssl_options[middle].name);
2545   if (c == 0)
2546     {
2547     *value = exim_openssl_options[middle].value;
2548     return TRUE;
2549     }
2550   else if (c > 0)
2551     first = middle + 1;
2552   else
2553     last = middle;
2554   }
2555 return FALSE;
2556 }
2557
2558
2559
2560
2561 /*************************************************
2562 *        OpenSSL option parsing logic            *
2563 *************************************************/
2564
2565 /* OpenSSL has a number of compatibility options which an administrator might
2566 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
2567 we look like log_selector.
2568
2569 Arguments:
2570   option_spec  the administrator-supplied string of options
2571   results      ptr to long storage for the options bitmap
2572 Returns        success or failure
2573 */
2574
2575 BOOL
2576 tls_openssl_options_parse(uschar *option_spec, long *results)
2577 {
2578 long result, item;
2579 uschar *s, *end;
2580 uschar keep_c;
2581 BOOL adding, item_parsed;
2582
2583 result = 0L;
2584 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
2585  * from default because it increases BEAST susceptibility. */
2586 #ifdef SSL_OP_NO_SSLv2
2587 result |= SSL_OP_NO_SSLv2;
2588 #endif
2589
2590 if (option_spec == NULL)
2591   {
2592   *results = result;
2593   return TRUE;
2594   }
2595
2596 for (s=option_spec; *s != '\0'; /**/)
2597   {
2598   while (isspace(*s)) ++s;
2599   if (*s == '\0')
2600     break;
2601   if (*s != '+' && *s != '-')
2602     {
2603     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
2604         "+ or - expected but found \"%s\"\n", s);
2605     return FALSE;
2606     }
2607   adding = *s++ == '+';
2608   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
2609   keep_c = *end;
2610   *end = '\0';
2611   item_parsed = tls_openssl_one_option_parse(s, &item);
2612   if (!item_parsed)
2613     {
2614     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
2615     return FALSE;
2616     }
2617   DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
2618       adding ? "adding" : "removing", result, item, s);
2619   if (adding)
2620     result |= item;
2621   else
2622     result &= ~item;
2623   *end = keep_c;
2624   s = end;
2625   }
2626
2627 *results = result;
2628 return TRUE;
2629 }
2630
2631 /* vi: aw ai sw=2
2632 */
2633 /* End of tls-openssl.c */