src/src/tls-openssl.c

   1 /* $Cambridge: exim/src/src/tls-openssl.c,v 1.12 2007/04/13 15:13:47 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2007 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   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
  26 /* Structure for collecting random data for seeding. */
  27
  28 typedef struct randstuff {
  29   time_t t;
  30   pid_t  p;
  31 } randstuff;
  32
  33 /* Local static variables */
  34
  35 static BOOL verify_callback_called = FALSE;
  36 static const uschar *sid_ctx = US"exim";
  37
  38 static SSL_CTX *ctx = NULL;
  39 static SSL *ssl = NULL;
  40
  41 static char ssl_errstring[256];
  42
  43 static int  ssl_session_timeout = 200;
  44 static BOOL verify_optional = FALSE;
  45
  46
  47
  48
  49
  50 /*************************************************
  51 *               Handle TLS error                 *
  52 *************************************************/
  53
  54 /* Called from lots of places when errors occur before actually starting to do
  55 the TLS handshake, that is, while the session is still in clear. Always returns
  56 DEFER for a server and FAIL for a client so that most calls can use "return
  57 tls_error(...)" to do this processing and then give an appropriate return. A
  58 single function is used for both server and client, because it is called from
  59 some shared functions.
  60
  61 Argument:
  62   prefix    text to include in the logged error
  63   host      NULL if setting up a server;
  64             the connected host if setting up a client
  65
  66 Returns:    OK/DEFER/FAIL
  67 */
  68
  69 static int
  70 tls_error(uschar *prefix, host_item *host)
  71 {
  72 ERR_error_string(ERR_get_error(), ssl_errstring);
  73 if (host == NULL)
  74   {
  75   log_write(0, LOG_MAIN, "TLS error on connection from %s (%s): %s",
  76     (sender_fullhost != NULL)? sender_fullhost : US"local process",
  77     prefix, ssl_errstring);
  78   return DEFER;
  79   }
  80 else
  81   {
  82   log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s): %s",
  83     host->name, host->address, prefix, ssl_errstring);
  84   return FAIL;
  85   }
  86 }
  87
  88
  89
  90 /*************************************************
  91 *        Callback to generate RSA key            *
  92 *************************************************/
  93
  94 /*
  95 Arguments:
  96   s          SSL connection
  97   export     not used
  98   keylength  keylength
  99
 100 Returns:     pointer to generated key
 101 */
 102
 103 static RSA *
 104 rsa_callback(SSL *s, int export, int keylength)
 105 {
 106 RSA *rsa_key;
 107 export = export;     /* Shut picky compilers up */
 108 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
 109 rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL);
 110 if (rsa_key == NULL)
 111   {
 112   ERR_error_string(ERR_get_error(), ssl_errstring);
 113   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
 114     ssl_errstring);
 115   return NULL;
 116   }
 117 return rsa_key;
 118 }
 119
 120
 121
 122
 123 /*************************************************
 124 *        Callback for verification               *
 125 *************************************************/
 126
 127 /* The SSL library does certificate verification if set up to do so. This
 128 callback has the current yes/no state is in "state". If verification succeeded,
 129 we set up the tls_peerdn string. If verification failed, what happens depends
 130 on whether the client is required to present a verifiable certificate or not.
 131
 132 If verification is optional, we change the state to yes, but still log the
 133 verification error. For some reason (it really would help to have proper
 134 documentation of OpenSSL), this callback function then gets called again, this
 135 time with state = 1. In fact, that's useful, because we can set up the peerdn
 136 value, but we must take care not to set the private verified flag on the second
 137 time through.
 138
 139 Note: this function is not called if the client fails to present a certificate
 140 when asked. We get here only if a certificate has been received. Handling of
 141 optional verification for this case is done when requesting SSL to verify, by
 142 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
 143
 144 Arguments:
 145   state      current yes/no state as 1/0
 146   x509ctx    certificate information.
 147
 148 Returns:     1 if verified, 0 if not
 149 */
 150
 151 static int
 152 verify_callback(int state, X509_STORE_CTX *x509ctx)
 153 {
 154 static uschar txt[256];
 155
 156 X509_NAME_oneline(X509_get_subject_name(x509ctx->current_cert),
 157   CS txt, sizeof(txt));
 158
 159 if (state == 0)
 160   {
 161   log_write(0, LOG_MAIN, "SSL verify error: depth=%d error=%s cert=%s",
 162     x509ctx->error_depth,
 163     X509_verify_cert_error_string(x509ctx->error),
 164     txt);
 165   tls_certificate_verified = FALSE;
 166   verify_callback_called = TRUE;
 167   if (!verify_optional) return 0;    /* reject */
 168   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
 169     "tls_try_verify_hosts)\n");
 170   return 1;                          /* accept */
 171   }
 172
 173 if (x509ctx->error_depth != 0)
 174   {
 175   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d cert=%s\n",
 176      x509ctx->error_depth, txt);
 177   }
 178 else
 179   {
 180   DEBUG(D_tls) debug_printf("SSL%s peer: %s\n",
 181     verify_callback_called? "" : " authenticated", txt);
 182   tls_peerdn = txt;
 183   }
 184
 185 if (!verify_callback_called) tls_certificate_verified = TRUE;
 186 verify_callback_called = TRUE;
 187
 188 return 1;   /* accept */
 189 }
 190
 191
 192
 193 /*************************************************
 194 *           Information callback                 *
 195 *************************************************/
 196
 197 /* The SSL library functions call this from time to time to indicate what they
 198 are doing. We copy the string to the debugging output when the level is high
 199 enough.
 200
 201 Arguments:
 202   s         the SSL connection
 203   where
 204   ret
 205
 206 Returns:    nothing
 207 */
 208
 209 static void
 210 info_callback(SSL *s, int where, int ret)
 211 {
 212 where = where;
 213 ret = ret;
 214 DEBUG(D_tls) debug_printf("SSL info: %s\n", SSL_state_string_long(s));
 215 }
 216
 217
 218
 219 /*************************************************
 220 *                Initialize for DH               *
 221 *************************************************/
 222
 223 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
 224
 225 Arguments:
 226   dhparam   DH parameter file
 227
 228 Returns:    TRUE if OK (nothing to set up, or setup worked)
 229 */
 230
 231 static BOOL
 232 init_dh(uschar *dhparam)
 233 {
 234 BOOL yield = TRUE;
 235 BIO *bio;
 236 DH *dh;
 237 uschar *dhexpanded;
 238
 239 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded))
 240   return FALSE;
 241
 242 if (dhexpanded == NULL) return TRUE;
 243
 244 if ((bio = BIO_new_file(CS dhexpanded, "r")) == NULL)
 245   {
 246   log_write(0, LOG_MAIN, "DH: could not read %s: %s", dhexpanded,
 247     strerror(errno));
 248   yield = FALSE;
 249   }
 250 else
 251   {
 252   if ((dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)) == NULL)
 253     {
 254     log_write(0, LOG_MAIN, "DH: could not load params from %s",
 255       dhexpanded);
 256     yield = FALSE;
 257     }
 258   else
 259     {
 260     SSL_CTX_set_tmp_dh(ctx, dh);
 261     DEBUG(D_tls)
 262       debug_printf("Diffie-Hellman initialized from %s with %d-bit key\n",
 263         dhexpanded, 8*DH_size(dh));
 264     DH_free(dh);
 265     }
 266   BIO_free(bio);
 267   }
 268
 269 return yield;
 270 }
 271
 272
 273
 274
 275 /*************************************************
 276 *            Initialize for TLS                  *
 277 *************************************************/
 278
 279 /* Called from both server and client code, to do preliminary initialization of
 280 the library.
 281
 282 Arguments:
 283   host            connected host, if client; NULL if server
 284   dhparam         DH parameter file
 285   certificate     certificate file
 286   privatekey      private key
 287   addr            address if client; NULL if server (for some randomness)
 288
 289 Returns:          OK/DEFER/FAIL
 290 */
 291
 292 static int
 293 tls_init(host_item *host, uschar *dhparam, uschar *certificate,
 294   uschar *privatekey, address_item *addr)
 295 {
 296 SSL_load_error_strings();          /* basic set up */
 297 OpenSSL_add_ssl_algorithms();
 298
 299 /* Create a context */
 300
 301 ctx = SSL_CTX_new((host == NULL)?
 302   SSLv23_server_method() : SSLv23_client_method());
 303
 304 if (ctx == NULL) return tls_error(US"SSL_CTX_new", host);
 305
 306 /* It turns out that we need to seed the random number generator this early in
 307 order to get the full complement of ciphers to work. It took me roughly a day
 308 of work to discover this by experiment.
 309
 310 On systems that have /dev/urandom, SSL may automatically seed itself from
 311 there. Otherwise, we have to make something up as best we can. Double check
 312 afterwards. */
 313
 314 if (!RAND_status())
 315   {
 316   randstuff r;
 317   r.t = time(NULL);
 318   r.p = getpid();
 319
 320   RAND_seed((uschar *)(&r), sizeof(r));
 321   RAND_seed((uschar *)big_buffer, big_buffer_size);
 322   if (addr != NULL) RAND_seed((uschar *)addr, sizeof(addr));
 323
 324   if (!RAND_status())
 325     {
 326     if (host == NULL)
 327       {
 328       log_write(0, LOG_MAIN, "TLS error on connection from %s: "
 329         "unable to seed random number generator",
 330         (sender_fullhost != NULL)? sender_fullhost : US"local process");
 331       return DEFER;
 332       }
 333     else
 334       {
 335       log_write(0, LOG_MAIN, "TLS error on connection to %s [%s]: "
 336         "unable to seed random number generator",
 337         host->name, host->address);
 338       return FAIL;
 339       }
 340     }
 341   }
 342
 343 /* Set up the information callback, which outputs if debugging is at a suitable
 344 level. */
 345
 346 SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
 347
 348 /* The following patch was supplied by Robert Roselius */
 349
 350 #if OPENSSL_VERSION_NUMBER > 0x00906040L
 351 /* Enable client-bug workaround.
 352    Versions of OpenSSL as of 0.9.6d include a "CBC countermeasure" feature,
 353    which causes problems with some clients (such as the Certicom SSL Plus
 354    library used by Eudora).  This option, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS,
 355    disables the coutermeasure allowing Eudora to connect.
 356    Some poppers and MTAs use SSL_OP_ALL, which enables all such bug
 357    workarounds. */
 358 /* XXX (Silently?) ignore failure here? XXX*/
 359
 360 if (!(SSL_CTX_set_options(ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)))
 361   return tls_error(US"SSL_CTX_set_option", host);
 362 #endif
 363
 364 /* Initialize with DH parameters if supplied */
 365
 366 if (!init_dh(dhparam)) return DEFER;
 367
 368 /* Set up certificate and key */
 369
 370 if (certificate != NULL)
 371   {
 372   uschar *expanded;
 373   if (!expand_check(certificate, US"tls_certificate", &expanded))
 374     return DEFER;
 375
 376   if (expanded != NULL)
 377     {
 378     DEBUG(D_tls) debug_printf("tls_certificate file %s\n", expanded);
 379     if (!SSL_CTX_use_certificate_chain_file(ctx, CS expanded))
 380       return tls_error(string_sprintf(
 381         "SSL_CTX_use_certificate_chain_file file=%s", expanded), host);
 382     }
 383
 384   if (privatekey != NULL &&
 385       !expand_check(privatekey, US"tls_privatekey", &expanded))
 386     return DEFER;
 387
 388   /* If expansion was forced to fail, key_expanded will be NULL. If the result
 389   of the expansion is an empty string, ignore it also, and assume the private
 390   key is in the same file as the certificate. */
 391
 392   if (expanded != NULL && *expanded != 0)
 393     {
 394     DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", expanded);
 395     if (!SSL_CTX_use_PrivateKey_file(ctx, CS expanded, SSL_FILETYPE_PEM))
 396       return tls_error(string_sprintf(
 397         "SSL_CTX_use_PrivateKey_file file=%s", expanded), host);
 398     }
 399   }
 400
 401 /* Set up the RSA callback */
 402
 403 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
 404
 405 /* Finally, set the timeout, and we are done */
 406
 407 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
 408 DEBUG(D_tls) debug_printf("Initialized TLS\n");
 409 return OK;
 410 }
 411
 412
 413
 414
 415 /*************************************************
 416 *           Get name of cipher in use            *
 417 *************************************************/
 418
 419 /* The answer is left in a static buffer, and tls_cipher is set to point
 420 to it.
 421
 422 Argument:   pointer to an SSL structure for the connection
 423 Returns:    nothing
 424 */
 425
 426 static void
 427 construct_cipher_name(SSL *ssl)
 428 {
 429 static uschar cipherbuf[256];
 430 SSL_CIPHER *c;
 431 uschar *ver;
 432 int bits;
 433
 434 switch (ssl->session->ssl_version)
 435   {
 436   case SSL2_VERSION:
 437   ver = US"SSLv2";
 438   break;
 439
 440   case SSL3_VERSION:
 441   ver = US"SSLv3";
 442   break;
 443
 444   case TLS1_VERSION:
 445   ver = US"TLSv1";
 446   break;
 447
 448   default:
 449   ver = US"UNKNOWN";
 450   }
 451
 452 c = SSL_get_current_cipher(ssl);
 453 SSL_CIPHER_get_bits(c, &bits);
 454
 455 string_format(cipherbuf, sizeof(cipherbuf), "%s:%s:%u", ver,
 456   SSL_CIPHER_get_name(c), bits);
 457 tls_cipher = cipherbuf;
 458
 459 DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
 460 }
 461
 462
 463
 464
 465
 466 /*************************************************
 467 *        Set up for verifying certificates       *
 468 *************************************************/
 469
 470 /* Called by both client and server startup
 471
 472 Arguments:
 473   certs         certs file or NULL
 474   crl           CRL file or NULL
 475   host          NULL in a server; the remote host in a client
 476   optional      TRUE if called from a server for a host in tls_try_verify_hosts;
 477                 otherwise passed as FALSE
 478
 479 Returns:        OK/DEFER/FAIL
 480 */
 481
 482 static int
 483 setup_certs(uschar *certs, uschar *crl, host_item *host, BOOL optional)
 484 {
 485 uschar *expcerts, *expcrl;
 486
 487 if (!expand_check(certs, US"tls_verify_certificates", &expcerts))
 488   return DEFER;
 489
 490 if (expcerts != NULL)
 491   {
 492   struct stat statbuf;
 493   if (!SSL_CTX_set_default_verify_paths(ctx))
 494     return tls_error(US"SSL_CTX_set_default_verify_paths", host);
 495
 496   if (Ustat(expcerts, &statbuf) < 0)
 497     {
 498     log_write(0, LOG_MAIN|LOG_PANIC,
 499       "failed to stat %s for certificates", expcerts);
 500     return DEFER;
 501     }
 502   else
 503     {
 504     uschar *file, *dir;
 505     if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
 506       { file = NULL; dir = expcerts; }
 507     else
 508       { file = expcerts; dir = NULL; }
 509
 510     /* If a certificate file is empty, the next function fails with an
 511     unhelpful error message. If we skip it, we get the correct behaviour (no
 512     certificates are recognized, but the error message is still misleading (it
 513     says no certificate was supplied.) But this is better. */
 514
 515     if ((file == NULL || statbuf.st_size > 0) &&
 516           !SSL_CTX_load_verify_locations(ctx, CS file, CS dir))
 517       return tls_error(US"SSL_CTX_load_verify_locations", host);
 518
 519     if (file != NULL)
 520       {
 521       SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CS file));
 522       }
 523     }
 524
 525   /* Handle a certificate revocation list. */
 526
 527   #if OPENSSL_VERSION_NUMBER > 0x00907000L
 528
 529   /* This bit of code is now the version supplied by Lars Mainka. (I have
 530    * merely reformatted it into the Exim code style.)
 531
 532    * "From here I changed the code to add support for multiple crl's
 533    * in pem format in one file or to support hashed directory entries in
 534    * pem format instead of a file. This method now uses the library function
 535    * X509_STORE_load_locations to add the CRL location to the SSL context.
 536    * OpenSSL will then handle the verify against CA certs and CRLs by
 537    * itself in the verify callback." */
 538
 539   if (!expand_check(crl, US"tls_crl", &expcrl)) return DEFER;
 540   if (expcrl != NULL && *expcrl != 0)
 541     {
 542     struct stat statbufcrl;
 543     if (Ustat(expcrl, &statbufcrl) < 0)
 544       {
 545       log_write(0, LOG_MAIN|LOG_PANIC,
 546         "failed to stat %s for certificates revocation lists", expcrl);
 547       return DEFER;
 548       }
 549     else
 550       {
 551       /* is it a file or directory? */
 552       uschar *file, *dir;
 553       X509_STORE *cvstore = SSL_CTX_get_cert_store(ctx);
 554       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
 555         {
 556         file = NULL;
 557         dir = expcrl;
 558         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
 559         }
 560       else
 561         {
 562         file = expcrl;
 563         dir = NULL;
 564         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
 565         }
 566       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
 567         return tls_error(US"X509_STORE_load_locations", host);
 568
 569       /* setting the flags to check against the complete crl chain */
 570
 571       X509_STORE_set_flags(cvstore,
 572         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
 573       }
 574     }
 575
 576   #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
 577
 578   /* If verification is optional, don't fail if no certificate */
 579
 580   SSL_CTX_set_verify(ctx,
 581     SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
 582     verify_callback);
 583   }
 584
 585 return OK;
 586 }
 587
 588
 589
 590 /*************************************************
 591 *       Start a TLS session in a server          *
 592 *************************************************/
 593
 594 /* This is called when Exim is running as a server, after having received
 595 the STARTTLS command. It must respond to that command, and then negotiate
 596 a TLS session.
 597
 598 Arguments:
 599   require_ciphers   allowed ciphers
 600   ------------------------------------------------------
 601   require_mac      list of allowed MACs                 ) Not used
 602   require_kx       list of allowed key_exchange methods )   for
 603   require_proto    list of allowed protocols            ) OpenSSL
 604   ------------------------------------------------------
 605
 606 Returns:            OK on success
 607                     DEFER for errors before the start of the negotiation
 608                     FAIL for errors during the negotation; the server can't
 609                       continue running.
 610 */
 611
 612 int
 613 tls_server_start(uschar *require_ciphers, uschar *require_mac,
 614   uschar *require_kx, uschar *require_proto)
 615 {
 616 int rc;
 617 uschar *expciphers;
 618
 619 /* Check for previous activation */
 620
 621 if (tls_active >= 0)
 622   {
 623   log_write(0, LOG_MAIN, "STARTTLS received in already encrypted "
 624     "connection from %s",
 625     (sender_fullhost != NULL)? sender_fullhost : US"local process");
 626   smtp_printf("554 Already in TLS\r\n");
 627   return FAIL;
 628   }
 629
 630 /* Initialize the SSL library. If it fails, it will already have logged
 631 the error. */
 632
 633 rc = tls_init(NULL, tls_dhparam, tls_certificate, tls_privatekey, NULL);
 634 if (rc != OK) return rc;
 635
 636 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers))
 637   return FAIL;
 638
 639 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
 640 are separated by underscores. So that I can use either form in my tests, and
 641 also for general convenience, we turn underscores into hyphens here. */
 642
 643 if (expciphers != NULL)
 644   {
 645   uschar *s = expciphers;
 646   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
 647   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
 648   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
 649     return tls_error(US"SSL_CTX_set_cipher_list", NULL);
 650   }
 651
 652 /* If this is a host for which certificate verification is mandatory or
 653 optional, set up appropriately. */
 654
 655 tls_certificate_verified = FALSE;
 656 verify_callback_called = FALSE;
 657
 658 if (verify_check_host(&tls_verify_hosts) == OK)
 659   {
 660   rc = setup_certs(tls_verify_certificates, tls_crl, NULL, FALSE);
 661   if (rc != OK) return rc;
 662   verify_optional = FALSE;
 663   }
 664 else if (verify_check_host(&tls_try_verify_hosts) == OK)
 665   {
 666   rc = setup_certs(tls_verify_certificates, tls_crl, NULL, TRUE);
 667   if (rc != OK) return rc;
 668   verify_optional = TRUE;
 669   }
 670
 671 /* Prepare for new connection */
 672
 673 if ((ssl = SSL_new(ctx)) == NULL) return tls_error(US"SSL_new", NULL);
 674 SSL_clear(ssl);
 675
 676 /* Set context and tell client to go ahead, except in the case of TLS startup
 677 on connection, where outputting anything now upsets the clients and tends to
 678 make them disconnect. We need to have an explicit fflush() here, to force out
 679 the response. Other smtp_printf() calls do not need it, because in non-TLS
 680 mode, the fflush() happens when smtp_getc() is called. */
 681
 682 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
 683 if (!tls_on_connect)
 684   {
 685   smtp_printf("220 TLS go ahead\r\n");
 686   fflush(smtp_out);
 687   }
 688
 689 /* Now negotiate the TLS session. We put our own timer on it, since it seems
 690 that the OpenSSL library doesn't. */
 691
 692 SSL_set_wfd(ssl, fileno(smtp_out));
 693 SSL_set_rfd(ssl, fileno(smtp_in));
 694 SSL_set_accept_state(ssl);
 695
 696 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
 697
 698 sigalrm_seen = FALSE;
 699 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
 700 rc = SSL_accept(ssl);
 701 alarm(0);
 702
 703 if (rc <= 0)
 704   {
 705   if (sigalrm_seen) Ustrcpy(ssl_errstring, "timed out");
 706     else ERR_error_string(ERR_get_error(), ssl_errstring);
 707   log_write(0, LOG_MAIN, "TLS error on connection from %s (SSL_accept): %s",
 708     (sender_fullhost != NULL)? sender_fullhost : US"local process",
 709     ssl_errstring);
 710   return FAIL;
 711   }
 712
 713 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
 714
 715 /* TLS has been set up. Adjust the input functions to read via TLS,
 716 and initialize things. */
 717
 718 construct_cipher_name(ssl);
 719
 720 DEBUG(D_tls)
 721   {
 722   uschar buf[2048];
 723   if (SSL_get_shared_ciphers(ssl, CS buf, sizeof(buf)) != NULL)
 724     debug_printf("Shared ciphers: %s\n", buf);
 725   }
 726
 727
 728 ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
 729 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
 730 ssl_xfer_eof = ssl_xfer_error = 0;
 731
 732 receive_getc = tls_getc;
 733 receive_ungetc = tls_ungetc;
 734 receive_feof = tls_feof;
 735 receive_ferror = tls_ferror;
 736 receive_smtp_buffered = tls_smtp_buffered;
 737
 738 tls_active = fileno(smtp_out);
 739 return OK;
 740 }
 741
 742
 743
 744
 745
 746 /*************************************************
 747 *    Start a TLS session in a client             *
 748 *************************************************/
 749
 750 /* Called from the smtp transport after STARTTLS has been accepted.
 751
 752 Argument:
 753   fd               the fd of the connection
 754   host             connected host (for messages)
 755   addr             the first address
 756   dhparam          DH parameter file
 757   certificate      certificate file
 758   privatekey       private key file
 759   verify_certs     file for certificate verify
 760   crl              file containing CRL
 761   require_ciphers  list of allowed ciphers
 762   ------------------------------------------------------
 763   require_mac      list of allowed MACs                 ) Not used
 764   require_kx       list of allowed key_exchange methods )   for
 765   require_proto    list of allowed protocols            ) OpenSSL
 766   ------------------------------------------------------
 767   timeout          startup timeout
 768
 769 Returns:           OK on success
 770                    FAIL otherwise - note that tls_error() will not give DEFER
 771                      because this is not a server
 772 */
 773
 774 int
 775 tls_client_start(int fd, host_item *host, address_item *addr, uschar *dhparam,
 776   uschar *certificate, uschar *privatekey, uschar *verify_certs, uschar *crl,
 777   uschar *require_ciphers, uschar *require_mac, uschar *require_kx,
 778   uschar *require_proto, int timeout)
 779 {
 780 static uschar txt[256];
 781 uschar *expciphers;
 782 X509* server_cert;
 783 int rc;
 784
 785 rc = tls_init(host, dhparam, certificate, privatekey, addr);
 786 if (rc != OK) return rc;
 787
 788 tls_certificate_verified = FALSE;
 789 verify_callback_called = FALSE;
 790
 791 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers))
 792   return FAIL;
 793
 794 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
 795 are separated by underscores. So that I can use either form in my tests, and
 796 also for general convenience, we turn underscores into hyphens here. */
 797
 798 if (expciphers != NULL)
 799   {
 800   uschar *s = expciphers;
 801   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
 802   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
 803   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
 804     return tls_error(US"SSL_CTX_set_cipher_list", host);
 805   }
 806
 807 rc = setup_certs(verify_certs, crl, host, FALSE);
 808 if (rc != OK) return rc;
 809
 810 if ((ssl = SSL_new(ctx)) == NULL) return tls_error(US"SSL_new", host);
 811 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
 812 SSL_set_fd(ssl, fd);
 813 SSL_set_connect_state(ssl);
 814
 815 /* There doesn't seem to be a built-in timeout on connection. */
 816
 817 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
 818 sigalrm_seen = FALSE;
 819 alarm(timeout);
 820 rc = SSL_connect(ssl);
 821 alarm(0);
 822
 823 if (rc <= 0)
 824   {
 825   if (sigalrm_seen)
 826     {
 827     log_write(0, LOG_MAIN, "TLS error on connection to %s [%s]: "
 828       "SSL_connect timed out", host->name, host->address);
 829     return FAIL;
 830     }
 831   else return tls_error(US"SSL_connect", host);
 832   }
 833
 834 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
 835
 836 server_cert = SSL_get_peer_certificate (ssl);
 837 tls_peerdn = US X509_NAME_oneline(X509_get_subject_name(server_cert),
 838   CS txt, sizeof(txt));
 839 tls_peerdn = txt;
 840
 841 construct_cipher_name(ssl);   /* Sets tls_cipher */
 842
 843 tls_active = fd;
 844 return OK;
 845 }
 846
 847
 848
 849
 850
 851 /*************************************************
 852 *            TLS version of getc                 *
 853 *************************************************/
 854
 855 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
 856 it refills the buffer via the SSL reading function.
 857
 858 Arguments:  none
 859 Returns:    the next character or EOF
 860 */
 861
 862 int
 863 tls_getc(void)
 864 {
 865 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
 866   {
 867   int error;
 868   int inbytes;
 869
 870   DEBUG(D_tls) debug_printf("Calling SSL_read(%lx, %lx, %u)\n", (long)ssl,
 871     (long)ssl_xfer_buffer, ssl_xfer_buffer_size);
 872
 873   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
 874   inbytes = SSL_read(ssl, CS ssl_xfer_buffer, ssl_xfer_buffer_size);
 875   error = SSL_get_error(ssl, inbytes);
 876   alarm(0);
 877
 878   /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
 879   closed down, not that the socket itself has been closed down. Revert to
 880   non-SSL handling. */
 881
 882   if (error == SSL_ERROR_ZERO_RETURN)
 883     {
 884     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
 885
 886     receive_getc = smtp_getc;
 887     receive_ungetc = smtp_ungetc;
 888     receive_feof = smtp_feof;
 889     receive_ferror = smtp_ferror;
 890     receive_smtp_buffered = smtp_buffered;
 891
 892     SSL_free(ssl);
 893     ssl = NULL;
 894     tls_active = -1;
 895     tls_cipher = NULL;
 896     tls_peerdn = NULL;
 897
 898     return smtp_getc();
 899     }
 900
 901   /* Handle genuine errors */
 902
 903   else if (error != SSL_ERROR_NONE)
 904     {
 905     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
 906     ssl_xfer_error = 1;
 907     return EOF;
 908     }
 909
 910   ssl_xfer_buffer_hwm = inbytes;
 911   ssl_xfer_buffer_lwm = 0;
 912   }
 913
 914 /* Something in the buffer; return next uschar */
 915
 916 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
 917 }
 918
 919
 920
 921 /*************************************************
 922 *          Read bytes from TLS channel           *
 923 *************************************************/
 924
 925 /*
 926 Arguments:
 927   buff      buffer of data
 928   len       size of buffer
 929
 930 Returns:    the number of bytes read
 931             -1 after a failed read
 932 */
 933
 934 int
 935 tls_read(uschar *buff, size_t len)
 936 {
 937 int inbytes;
 938 int error;
 939
 940 DEBUG(D_tls) debug_printf("Calling SSL_read(%lx, %lx, %u)\n", (long)ssl,
 941   (long)buff, (unsigned int)len);
 942
 943 inbytes = SSL_read(ssl, CS buff, len);
 944 error = SSL_get_error(ssl, inbytes);
 945
 946 if (error == SSL_ERROR_ZERO_RETURN)
 947   {
 948   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
 949   return -1;
 950   }
 951 else if (error != SSL_ERROR_NONE)
 952   {
 953   return -1;
 954   }
 955
 956 return inbytes;
 957 }
 958
 959
 960
 961
 962
 963 /*************************************************
 964 *         Write bytes down TLS channel           *
 965 *************************************************/
 966
 967 /*
 968 Arguments:
 969   buff      buffer of data
 970   len       number of bytes
 971
 972 Returns:    the number of bytes after a successful write,
 973             -1 after a failed write
 974 */
 975
 976 int
 977 tls_write(const uschar *buff, size_t len)
 978 {
 979 int outbytes;
 980 int error;
 981 int left = len;
 982
 983 DEBUG(D_tls) debug_printf("tls_do_write(%lx, %d)\n", (long)buff, left);
 984 while (left > 0)
 985   {
 986   DEBUG(D_tls) debug_printf("SSL_write(SSL, %lx, %d)\n", (long)buff, left);
 987   outbytes = SSL_write(ssl, CS buff, left);
 988   error = SSL_get_error(ssl, outbytes);
 989   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
 990   switch (error)
 991     {
 992     case SSL_ERROR_SSL:
 993     ERR_error_string(ERR_get_error(), ssl_errstring);
 994     log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
 995     return -1;
 996
 997     case SSL_ERROR_NONE:
 998     left -= outbytes;
 999     buff += outbytes;
1000     break;
1001
1002     case SSL_ERROR_ZERO_RETURN:
1003     log_write(0, LOG_MAIN, "SSL channel closed on write");
1004     return -1;
1005
1006     default:
1007     log_write(0, LOG_MAIN, "SSL_write error %d", error);
1008     return -1;
1009     }
1010   }
1011 return len;
1012 }
1013
1014
1015
1016 /*************************************************
1017 *         Close down a TLS session               *
1018 *************************************************/
1019
1020 /* This is also called from within a delivery subprocess forked from the
1021 daemon, to shut down the TLS library, without actually doing a shutdown (which
1022 would tamper with the SSL session in the parent process).
1023
1024 Arguments:   TRUE if SSL_shutdown is to be called
1025 Returns:     nothing
1026 */
1027
1028 void
1029 tls_close(BOOL shutdown)
1030 {
1031 if (tls_active < 0) return;  /* TLS was not active */
1032
1033 if (shutdown)
1034   {
1035   DEBUG(D_tls) debug_printf("tls_close(): shutting down SSL\n");
1036   SSL_shutdown(ssl);
1037   }
1038
1039 SSL_free(ssl);
1040 ssl = NULL;
1041
1042 tls_active = -1;
1043 }
1044
1045 /* End of tls-openssl.c */