src/src/tls-gnu.c

   1 /* $Cambridge: exim/src/src/tls-gnu.c,v 1.21 2009/06/10 07:34:04 tom 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 TLS (aka SSL) support for Exim using the GnuTLS
  11 library. It is #included into tls.c when that library is used. The code herein
  12 is based on a patch that was contributed by Nikos Mavroyanopoulos.
  13
  14 No cryptographic code is included in Exim. All this module does is to call
  15 functions from the GnuTLS library. */
  16
  17
  18 /* Heading stuff for GnuTLS */
  19
  20 #include <gnutls/gnutls.h>
  21 #include <gnutls/x509.h>
  22
  23
  24 #define UNKNOWN_NAME "unknown"
  25 #define DH_BITS      1024
  26 #define PARAM_SIZE 2*1024
  27
  28
  29 /* Values for verify_requirment */
  30
  31 enum { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED };
  32
  33 /* Local static variables for GNUTLS */
  34
  35 static host_item *client_host;
  36
  37 static gnutls_dh_params dh_params = NULL;
  38
  39 static gnutls_certificate_server_credentials x509_cred = NULL;
  40 static gnutls_session tls_session = NULL;
  41
  42 static char ssl_errstring[256];
  43
  44 static int  ssl_session_timeout = 200;
  45 static int  verify_requirement;
  46
  47 /* Priorities for TLS algorithms to use. In each case there's a default table,
  48 and space into which it can be copied and altered. */
  49
  50 static const int default_proto_priority[16] = {
  51   GNUTLS_TLS1,
  52   GNUTLS_SSL3,
  53   0 };
  54
  55 static int proto_priority[16];
  56
  57 static const int default_kx_priority[16] = {
  58   GNUTLS_KX_RSA,
  59   GNUTLS_KX_DHE_DSS,
  60   GNUTLS_KX_DHE_RSA,
  61   0 };
  62
  63 static int kx_priority[16];
  64
  65 static int default_cipher_priority[16] = {
  66   GNUTLS_CIPHER_AES_256_CBC,
  67   GNUTLS_CIPHER_AES_128_CBC,
  68   GNUTLS_CIPHER_3DES_CBC,
  69   GNUTLS_CIPHER_ARCFOUR_128,
  70   0 };
  71
  72 static int cipher_priority[16];
  73
  74 static const int default_mac_priority[16] = {
  75   GNUTLS_MAC_SHA,
  76   GNUTLS_MAC_MD5,
  77   0 };
  78
  79 static int mac_priority[16];
  80
  81 /* These two are currently not changeable. */
  82
  83 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
  84 static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 };
  85
  86 /* Tables of priority names and equivalent numbers */
  87
  88 typedef struct pri_item {
  89   uschar *name;
  90   int *values;
  91 } pri_item;
  92
  93
  94 static int tls1_codes[] = { GNUTLS_TLS1, 0 };
  95 static int ssl3_codes[] = { GNUTLS_SSL3, 0 };
  96
  97 static pri_item proto_index[] = {
  98   { US"TLS1", tls1_codes },
  99   { US"SSL3", ssl3_codes }
 100 };
 101
 102
 103 static int kx_rsa_codes[]      = { GNUTLS_KX_RSA,
 104                                    GNUTLS_KX_DHE_RSA, 0 };
 105 static int kx_dhe_codes[]      = { GNUTLS_KX_DHE_DSS,
 106                                    GNUTLS_KX_DHE_RSA, 0 };
 107 static int kx_dhe_dss_codes[]  = { GNUTLS_KX_DHE_DSS, 0 };
 108 static int kx_dhe_rsa_codes[]  = { GNUTLS_KX_DHE_RSA, 0 };
 109
 110 static pri_item kx_index[] = {
 111   { US"DHE_DSS", kx_dhe_dss_codes },
 112   { US"DHE_RSA", kx_dhe_rsa_codes },
 113   { US"RSA", kx_rsa_codes },
 114   { US"DHE", kx_dhe_codes }
 115 };
 116
 117
 118 static int arcfour_128_codes[] = { GNUTLS_CIPHER_ARCFOUR_128, 0 };
 119 static int arcfour_40_codes[]  = { GNUTLS_CIPHER_ARCFOUR_40, 0 };
 120 static int arcfour_codes[]     = { GNUTLS_CIPHER_ARCFOUR_128,
 121                                    GNUTLS_CIPHER_ARCFOUR_40, 0 };
 122 static int aes_256_codes[]     = { GNUTLS_CIPHER_AES_256_CBC, 0 };
 123 static int aes_128_codes[]     = { GNUTLS_CIPHER_AES_128_CBC, 0 };
 124 static int aes_codes[]         = { GNUTLS_CIPHER_AES_256_CBC,
 125                                    GNUTLS_CIPHER_AES_128_CBC, 0 };
 126 static int des3_codes[]        = { GNUTLS_CIPHER_3DES_CBC, 0 };
 127
 128 static pri_item cipher_index[] = {
 129   { US"ARCFOUR_128", arcfour_128_codes },
 130   { US"ARCFOUR_40", arcfour_40_codes },
 131   { US"ARCFOUR", arcfour_codes },
 132   { US"AES_256", aes_256_codes },
 133   { US"AES_128", aes_128_codes },
 134   { US"AES", aes_codes },
 135   { US"3DES", des3_codes }
 136 };
 137
 138
 139 static int mac_sha_codes[]     = { GNUTLS_MAC_SHA, 0 };
 140 static int mac_md5_codes[]     = { GNUTLS_MAC_MD5, 0 };
 141
 142 static pri_item mac_index[] = {
 143   { US"SHA",  mac_sha_codes },
 144   { US"SHA1", mac_sha_codes },
 145   { US"MD5",  mac_md5_codes }
 146 };
 147
 148
 149
 150 /*************************************************
 151 *               Handle TLS error                 *
 152 *************************************************/
 153
 154 /* Called from lots of places when errors occur before actually starting to do
 155 the TLS handshake, that is, while the session is still in clear. Always returns
 156 DEFER for a server and FAIL for a client so that most calls can use "return
 157 tls_error(...)" to do this processing and then give an appropriate return. A
 158 single function is used for both server and client, because it is called from
 159 some shared functions.
 160
 161 Argument:
 162   prefix    text to include in the logged error
 163   host      NULL if setting up a server;
 164             the connected host if setting up a client
 165   msg       additional error string (may be NULL)
 166             usually obtained from gnutls_strerror()
 167
 168 Returns:    OK/DEFER/FAIL
 169 */
 170
 171 static int
 172 tls_error(uschar *prefix, host_item *host, const char *msg)
 173 {
 174 if (host == NULL)
 175   {
 176   uschar *conn_info = smtp_get_connection_info();
 177   if (strncmp(conn_info, "SMTP ", 5) == 0)
 178     conn_info += 5;
 179   log_write(0, LOG_MAIN, "TLS error on %s (%s)%s%s",
 180     conn_info, prefix, msg ? ": " : "", msg ? msg : "");
 181   return DEFER;
 182   }
 183 else
 184   {
 185   log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s)%s%s",
 186     host->name, host->address, prefix, msg ? ": " : "", msg ? msg : "");
 187   return FAIL;
 188   }
 189 }
 190
 191
 192
 193 /*************************************************
 194 *             Verify certificate                 *
 195 *************************************************/
 196
 197 /* Called after a successful handshake, when certificate verification is
 198 required or optional, for both server and client.
 199
 200 Arguments:
 201   session    GNUTLS session
 202   error      where to put text giving a reason for failure
 203
 204 Returns:     TRUE/FALSE
 205 */
 206
 207 static BOOL
 208 verify_certificate(gnutls_session session, const char **error)
 209 {
 210 int verify;
 211 uschar *dn_string = US"";
 212 const gnutls_datum *cert;
 213 unsigned int cert_size = 0;
 214
 215 *error = NULL;
 216
 217 /* Get the peer's certificate. If it sent one, extract it's DN, and then
 218 attempt to verify the certificate. If no certificate is supplied, verification
 219 is forced to fail. */
 220
 221 cert = gnutls_certificate_get_peers(session, &cert_size);
 222 if (cert != NULL)
 223   {
 224   uschar buff[1024];
 225   gnutls_x509_crt gcert;
 226
 227   gnutls_x509_crt_init(&gcert);
 228   dn_string = US"unknown";
 229
 230   if (gnutls_x509_crt_import(gcert, cert, GNUTLS_X509_FMT_DER) == 0)
 231     {
 232     size_t bufsize = sizeof(buff);
 233     if (gnutls_x509_crt_get_dn(gcert, CS buff, &bufsize) >= 0)
 234       dn_string = string_copy_malloc(buff);
 235     }
 236
 237   verify = gnutls_certificate_verify_peers(session);
 238   }
 239 else
 240   {
 241   DEBUG(D_tls) debug_printf("no peer certificate supplied\n");
 242   verify = GNUTLS_CERT_INVALID;
 243   *error = "not supplied";
 244   }
 245
 246 /* Handle the result of verification. INVALID seems to be set as well
 247 as REVOKED, but leave the test for both. */
 248
 249 if ((verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED)) != 0)
 250   {
 251   tls_certificate_verified = FALSE;
 252   if (*error == NULL) *error = ((verify & GNUTLS_CERT_REVOKED) != 0)?
 253     "revoked" : "invalid";
 254   if (verify_requirement == VERIFY_REQUIRED)
 255     {
 256     DEBUG(D_tls) debug_printf("TLS certificate verification failed (%s): "
 257       "peerdn=%s\n", *error, dn_string);
 258     gnutls_alert_send(session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
 259     return FALSE;                       /* reject */
 260     }
 261   DEBUG(D_tls) debug_printf("TLS certificate verify failure (%s) overridden "
 262       "(host in tls_try_verify_hosts): peerdn=%s\n", *error, dn_string);
 263   }
 264 else
 265   {
 266   tls_certificate_verified = TRUE;
 267   DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=%s\n",
 268     dn_string);
 269   }
 270
 271 tls_peerdn = dn_string;
 272 return TRUE;                            /* accept */
 273 }
 274
 275
 276
 277 /*************************************************
 278 *            Setup up DH parameters              *
 279 *************************************************/
 280
 281 /* Generating the D-H parameters may take a long time. They only need to
 282 be re-generated every so often, depending on security policy. What we do is to
 283 keep these parameters in a file in the spool directory. If the file does not
 284 exist, we generate them. This means that it is easy to cause a regeneration.
 285
 286 The new file is written as a temporary file and renamed, so that an incomplete
 287 file is never present. If two processes both compute some new parameters, you
 288 waste a bit of effort, but it doesn't seem worth messing around with locking to
 289 prevent this.
 290
 291 Argument:
 292   host       NULL for server, server for client (for error handling)
 293
 294 Returns:     OK/DEFER/FAIL
 295 */
 296
 297 static int
 298 init_dh(host_item *host)
 299 {
 300 int fd;
 301 int ret;
 302 gnutls_datum m;
 303 uschar filename[200];
 304
 305 /* Initialize the data structures for holding the parameters */
 306
 307 ret = gnutls_dh_params_init(&dh_params);
 308 if (ret < 0) return tls_error(US"init dh_params", host, gnutls_strerror(ret));
 309
 310 /* Set up the name of the cache file */
 311
 312 if (!string_format(filename, sizeof(filename), "%s/gnutls-params",
 313       spool_directory))
 314   return tls_error(US"overlong filename", host, NULL);
 315
 316 /* Open the cache file for reading and if successful, read it and set up the
 317 parameters. */
 318
 319 fd = Uopen(filename, O_RDONLY, 0);
 320 if (fd >= 0)
 321   {
 322   struct stat statbuf;
 323   if (fstat(fd, &statbuf) < 0)
 324     {
 325     (void)close(fd);
 326     return tls_error(US"TLS cache stat failed", host, strerror(errno));
 327     }
 328
 329   m.size = statbuf.st_size;
 330   m.data = malloc(m.size);
 331   if (m.data == NULL)
 332     return tls_error(US"memory allocation failed", host, strerror(errno));
 333   errno = 0;
 334   if (read(fd, m.data, m.size) != m.size)
 335     return tls_error(US"TLS cache read failed", host, strerror(errno));
 336   (void)close(fd);
 337
 338   ret = gnutls_dh_params_import_pkcs3(dh_params, &m, GNUTLS_X509_FMT_PEM);
 339   if (ret < 0)
 340     return tls_error(US"DH params import", host, gnutls_strerror(ret));
 341   DEBUG(D_tls) debug_printf("read D-H parameters from file\n");
 342
 343   free(m.data);
 344   }
 345
 346 /* If the file does not exist, fall through to compute new data and cache it.
 347 If there was any other opening error, it is serious. */
 348
 349 else if (errno == ENOENT)
 350   {
 351   ret = -1;
 352   DEBUG(D_tls)
 353     debug_printf("parameter cache file %s does not exist\n", filename);
 354   }
 355 else
 356   return tls_error(string_open_failed(errno, "%s for reading", filename),
 357     host, NULL);
 358
 359 /* If ret < 0, either the cache file does not exist, or the data it contains
 360 is not useful. One particular case of this is when upgrading from an older
 361 release of Exim in which the data was stored in a different format. We don't
 362 try to be clever and support both formats; we just regenerate new data in this
 363 case. */
 364
 365 if (ret < 0)
 366   {
 367   uschar tempfilename[sizeof(filename) + 10];
 368
 369   DEBUG(D_tls) debug_printf("generating %d bit Diffie-Hellman key...\n",
 370     DH_BITS);
 371   ret = gnutls_dh_params_generate2(dh_params, DH_BITS);
 372   if (ret < 0) return tls_error(US"D-H key generation", host, gnutls_strerror(ret));
 373
 374   /* Write the parameters to a file in the spool directory so that we
 375   can use them from other Exim processes. */
 376
 377   sprintf(CS tempfilename, "%s-%d", filename, (int)getpid());
 378   fd = Uopen(tempfilename, O_WRONLY|O_CREAT, 0400);
 379   if (fd < 0)
 380     return tls_error(string_open_failed(errno, "%s for writing", filename),
 381       host, NULL);
 382   (void)fchown(fd, exim_uid, exim_gid);   /* Probably not necessary */
 383
 384   /* export the parameters in a format that can be generated using GNUTLS'
 385    * certtool or other programs.
 386    *
 387    * The commands for certtool are:
 388    * $ certtool --generate-dh-params --bits 1024 > params
 389    */
 390
 391   m.size = PARAM_SIZE;
 392   m.data = malloc(m.size);
 393   if (m.data == NULL)
 394     return tls_error(US"memory allocation failed", host, strerror(errno));
 395
 396   m.size = PARAM_SIZE;
 397   ret = gnutls_dh_params_export_pkcs3(dh_params, GNUTLS_X509_FMT_PEM, m.data,
 398     &m.size);
 399   if (ret < 0)
 400     return tls_error(US"DH params export", host, gnutls_strerror(ret));
 401
 402   m.size = Ustrlen(m.data);
 403   errno = 0;
 404   if (write(fd, m.data, m.size) != m.size || write(fd, "\n", 1) != 1)
 405     return tls_error(US"TLS cache write failed", host, strerror(errno));
 406
 407   free(m.data);
 408   (void)close(fd);
 409
 410   if (rename(CS tempfilename, CS filename) < 0)
 411     return tls_error(string_sprintf("failed to rename %s as %s",
 412       tempfilename, filename), host, strerror(errno));
 413
 414   DEBUG(D_tls) debug_printf("wrote D-H parameters to file %s\n", filename);
 415   }
 416
 417 DEBUG(D_tls) debug_printf("initialized D-H parameters\n");
 418 return OK;
 419 }
 420
 421
 422
 423
 424 /*************************************************
 425 *            Initialize for GnuTLS               *
 426 *************************************************/
 427
 428 /* Called from both server and client code. In the case of a server, errors
 429 before actual TLS negotiation return DEFER.
 430
 431 Arguments:
 432   host            connected host, if client; NULL if server
 433   certificate     certificate file
 434   privatekey      private key file
 435   cas             CA certs file
 436   crl             CRL file
 437
 438 Returns:          OK/DEFER/FAIL
 439 */
 440
 441 static int
 442 tls_init(host_item *host, uschar *certificate, uschar *privatekey, uschar *cas,
 443   uschar *crl)
 444 {
 445 int rc;
 446 uschar *cert_expanded, *key_expanded, *cas_expanded, *crl_expanded;
 447
 448 client_host = host;
 449
 450 rc = gnutls_global_init();
 451 if (rc < 0) return tls_error(US"tls-init", host, gnutls_strerror(rc));
 452
 453 /* Create D-H parameters, or read them from the cache file. This function does
 454 its own SMTP error messaging. */
 455
 456 rc = init_dh(host);
 457 if (rc != OK) return rc;
 458
 459 /* Create the credentials structure */
 460
 461 rc = gnutls_certificate_allocate_credentials(&x509_cred);
 462 if (rc < 0)
 463   return tls_error(US"certificate_allocate_credentials",
 464     host, gnutls_strerror(rc));
 465
 466 /* This stuff must be done for each session, because different certificates
 467 may be required for different sessions. */
 468
 469 if (!expand_check(certificate, US"tls_certificate", &cert_expanded))
 470   return DEFER;
 471
 472 key_expanded = NULL;
 473 if (privatekey != NULL)
 474   {
 475   if (!expand_check(privatekey, US"tls_privatekey", &key_expanded))
 476     return DEFER;
 477   }
 478
 479 /* If expansion was forced to fail, key_expanded will be NULL. If the result of
 480 the expansion is an empty string, ignore it also, and assume that the private
 481 key is in the same file as the certificate. */
 482
 483 if (key_expanded == NULL || *key_expanded == 0)
 484   key_expanded = cert_expanded;
 485
 486 /* Set the certificate and private keys */
 487
 488 if (cert_expanded != NULL)
 489   {
 490   DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
 491     cert_expanded, key_expanded);
 492   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS cert_expanded,
 493     CS key_expanded, GNUTLS_X509_FMT_PEM);
 494   if (rc < 0)
 495     {
 496     uschar *msg = string_sprintf("cert/key setup: cert=%s key=%s",
 497       cert_expanded, key_expanded);
 498     return tls_error(msg, host, gnutls_strerror(rc));
 499     }
 500   }
 501
 502 /* A certificate is mandatory in a server, but not in a client */
 503
 504 else
 505   {
 506   if (host == NULL)
 507     return tls_error(US"no TLS server certificate is specified", NULL, NULL);
 508   DEBUG(D_tls) debug_printf("no TLS client certificate is specified\n");
 509   }
 510
 511 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
 512 provided. Experiment shows that, if the certificate file is empty, an unhelpful
 513 error message is provided. However, if we just refrain from setting anything up
 514 in that case, certificate verification fails, which seems to be the correct
 515 behaviour. */
 516
 517 if (cas != NULL)
 518   {
 519   struct stat statbuf;
 520
 521   if (!expand_check(cas, US"tls_verify_certificates", &cas_expanded))
 522     return DEFER;
 523
 524   if (stat(CS cas_expanded, &statbuf) < 0)
 525     {
 526     log_write(0, LOG_MAIN|LOG_PANIC, "could not stat %s "
 527       "(tls_verify_certificates): %s", cas_expanded, strerror(errno));
 528     return DEFER;
 529     }
 530
 531   DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
 532     cas_expanded, statbuf.st_size);
 533
 534   /* If the cert file is empty, there's no point in loading the CRL file. */
 535
 536   if (statbuf.st_size > 0)
 537     {
 538     rc = gnutls_certificate_set_x509_trust_file(x509_cred, CS cas_expanded,
 539       GNUTLS_X509_FMT_PEM);
 540     if (rc < 0) return tls_error(US"setup_certs", host, gnutls_strerror(rc));
 541
 542     if (crl != NULL && *crl != 0)
 543       {
 544       if (!expand_check(crl, US"tls_crl", &crl_expanded))
 545         return DEFER;
 546       DEBUG(D_tls) debug_printf("loading CRL file = %s\n", crl_expanded);
 547       rc = gnutls_certificate_set_x509_crl_file(x509_cred, CS crl_expanded,
 548         GNUTLS_X509_FMT_PEM);
 549       if (rc < 0) return tls_error(US"CRL setup", host, gnutls_strerror(rc));
 550       }
 551     }
 552   }
 553
 554 /* Associate the parameters with the x509 credentials structure. */
 555
 556 gnutls_certificate_set_dh_params(x509_cred, dh_params);
 557
 558 DEBUG(D_tls) debug_printf("initialized certificate stuff\n");
 559 return OK;
 560 }
 561
 562
 563
 564
 565 /*************************************************
 566 *           Remove from a priority list          *
 567 *************************************************/
 568
 569 /* Cautiously written so that it will remove duplicates if present.
 570
 571 Arguments:
 572   list         a zero-terminated list
 573   remove_list  a zero-terminated list to be removed
 574
 575 Returns:       nothing
 576 */
 577
 578 static void
 579 remove_priority(int *list, int *remove_list)
 580 {
 581 for (; *remove_list != 0; remove_list++)
 582   {
 583   int *p = list;
 584   while (*p != 0)
 585     {
 586     if (*p == *remove_list)
 587       {
 588       int *pp = p;
 589       do { pp[0] = pp[1]; pp++; } while (*pp != 0);
 590       }
 591     else p++;
 592     }
 593   }
 594 }
 595
 596
 597
 598 /*************************************************
 599 *            Add to a priority list              *
 600 *************************************************/
 601
 602 /* Cautiously written to check the list size
 603
 604 Arguments:
 605   list         a zero-terminated list
 606   list_max     maximum offset in the list
 607   add_list     a zero-terminated list to be added
 608
 609 Returns:       TRUE if OK; FALSE if list overflows
 610 */
 611
 612 static BOOL
 613 add_priority(int *list, int list_max, int *add_list)
 614 {
 615 int next = 0;
 616 while (list[next] != 0) next++;
 617 while (*add_list != 0)
 618   {
 619   if (next >= list_max) return FALSE;
 620   list[next++] = *add_list++;
 621   }
 622 list[next] = 0;
 623 return TRUE;
 624 }
 625
 626
 627
 628 /*************************************************
 629 *          Adjust a priority list                *
 630 *************************************************/
 631
 632 /* This function is called to adjust the lists of cipher algorithms, MAC
 633 algorithms, key-exchange methods, and protocols.
 634
 635 Arguments:
 636   plist       the appropriate priority list
 637   psize       the length of the list
 638   s           the configuation string
 639   index       the index of recognized strings
 640   isize       the length of the index
 641
 642
 643   which       text for an error message
 644
 645 Returns:      FALSE if the table overflows, else TRUE
 646 */
 647
 648 static BOOL
 649 set_priority(int *plist, int psize, uschar *s, pri_item *index, int isize,
 650    uschar *which)
 651 {
 652 int sep = 0;
 653 BOOL first = TRUE;
 654 uschar *t;
 655
 656 while ((t = string_nextinlist(&s, &sep, big_buffer, big_buffer_size)) != NULL)
 657   {
 658   int i;
 659   BOOL exclude = t[0] == '!';
 660   if (first && !exclude) plist[0] = 0;
 661   first = FALSE;
 662   for (i = 0; i < isize; i++)
 663     {
 664     uschar *ss = strstric(t, index[i].name, FALSE);
 665     if (ss != NULL)
 666       {
 667       uschar *endss = ss + Ustrlen(index[i].name);
 668       if ((ss == t || !isalnum(ss[-1])) && !isalnum(*endss))
 669         {
 670         if (exclude)
 671           remove_priority(plist, index[i].values);
 672         else
 673           {
 674           if (!add_priority(plist, psize, index[i].values))
 675             {
 676             log_write(0, LOG_MAIN|LOG_PANIC, "GnuTLS init failed: %s "
 677               "priority table overflow", which);
 678             return FALSE;
 679             }
 680           }
 681         }
 682       }
 683     }
 684   }
 685
 686 DEBUG(D_tls)
 687   {
 688   int *ptr = plist;
 689   debug_printf("adjusted %s priorities:", which);
 690   while (*ptr != 0) debug_printf(" %d", *ptr++);
 691   debug_printf("\n");
 692   }
 693
 694 return TRUE;
 695 }
 696
 697
 698
 699
 700 /*************************************************
 701 *        Initialize a single GNUTLS session      *
 702 *************************************************/
 703
 704 /* Set the algorithm, the db backend, whether to request certificates etc.
 705
 706 TLS in Exim was first implemented using OpenSSL. This has a function to which
 707 you pass a list of cipher suites that are permitted/not permitted. GnuTLS works
 708 differently. It operates using priority lists for the different components of
 709 cipher suites.
 710
 711 For compatibility of configuration, we scan a list of cipher suites and set
 712 priorities therefrom. However, at the moment, we pay attention only to the bulk
 713 cipher.
 714
 715 Arguments:
 716   side         one of GNUTLS_SERVER, GNUTLS_CLIENT
 717   expciphers   expanded ciphers list or NULL
 718   expmac       expanded MAC list or NULL
 719   expkx        expanded key-exchange list or NULL
 720   expproto     expanded protocol list or NULL
 721
 722 Returns:  a gnutls_session, or NULL if there is a problem
 723 */
 724
 725 static gnutls_session
 726 tls_session_init(int side, uschar *expciphers, uschar *expmac, uschar *expkx,
 727   uschar *expproto)
 728 {
 729 gnutls_session session;
 730
 731 gnutls_init(&session, side);
 732
 733 /* Initialize the lists of permitted protocols, key-exchange methods, ciphers,
 734 and MACs. */
 735
 736 memcpy(cipher_priority, default_cipher_priority, sizeof(cipher_priority));
 737 memcpy(mac_priority, default_mac_priority, sizeof(mac_priority));
 738 memcpy(kx_priority, default_kx_priority, sizeof(kx_priority));
 739 memcpy(proto_priority, default_proto_priority, sizeof(proto_priority));
 740
 741 /* The names OpenSSL uses in tls_require_ciphers are of the form DES-CBC3-SHA,
 742 using hyphen separators. GnuTLS uses underscore separators. So that I can use
 743 either form for tls_require_ciphers in my tests, and also for general
 744 convenience, we turn hyphens into underscores before scanning the list. */
 745
 746 if (expciphers != NULL)
 747   {
 748   uschar *s = expciphers;
 749   while (*s != 0) { if (*s == '-') *s = '_'; s++; }
 750   }
 751
 752 if ((expciphers != NULL &&
 753       !set_priority(cipher_priority, sizeof(cipher_priority)/sizeof(int),
 754         expciphers, cipher_index, sizeof(cipher_index)/sizeof(pri_item),
 755         US"cipher")) ||
 756     (expmac != NULL &&
 757       !set_priority(mac_priority, sizeof(mac_priority)/sizeof(int),
 758         expmac, mac_index, sizeof(mac_index)/sizeof(pri_item),
 759         US"MAC")) ||
 760     (expkx != NULL &&
 761       !set_priority(kx_priority, sizeof(kx_priority)/sizeof(int),
 762         expkx, kx_index, sizeof(kx_index)/sizeof(pri_item),
 763         US"key-exchange")) ||
 764     (expproto != NULL &&
 765       !set_priority(proto_priority, sizeof(proto_priority)/sizeof(int),
 766         expproto, proto_index, sizeof(proto_index)/sizeof(pri_item),
 767         US"protocol")))
 768   {
 769   gnutls_deinit(session);
 770   return NULL;
 771   }
 772
 773 /* Define the various priorities */
 774
 775 gnutls_cipher_set_priority(session, cipher_priority);
 776 gnutls_compression_set_priority(session, comp_priority);
 777 gnutls_kx_set_priority(session, kx_priority);
 778 gnutls_protocol_set_priority(session, proto_priority);
 779 gnutls_mac_set_priority(session, mac_priority);
 780
 781 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
 782
 783 gnutls_dh_set_prime_bits(session, DH_BITS);
 784
 785 /* Request or demand a certificate of the peer, as configured. This will
 786 happen only in a server. */
 787
 788 if (verify_requirement != VERIFY_NONE)
 789   gnutls_certificate_server_set_request(session,
 790     (verify_requirement == VERIFY_OPTIONAL)?
 791       GNUTLS_CERT_REQUEST : GNUTLS_CERT_REQUIRE);
 792
 793 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
 794
 795 DEBUG(D_tls) debug_printf("initialized GnuTLS session\n");
 796 return session;
 797 }
 798
 799
 800
 801 /*************************************************
 802 *           Get name of cipher in use            *
 803 *************************************************/
 804
 805 /* The answer is left in a static buffer, and tls_cipher is set to point
 806 to it.
 807
 808 Argument:   pointer to a GnuTLS session
 809 Returns:    nothing
 810 */
 811
 812 static void
 813 construct_cipher_name(gnutls_session session)
 814 {
 815 static uschar cipherbuf[256];
 816 uschar *ver;
 817 int bits, c, kx, mac;
 818
 819 ver = string_copy(
 820   US gnutls_protocol_get_name(gnutls_protocol_get_version(session)));
 821 if (Ustrncmp(ver, "TLS ", 4) == 0) ver[3] = '-';   /* Don't want space */
 822
 823 c = gnutls_cipher_get(session);
 824 bits = gnutls_cipher_get_key_size(c);
 825
 826 mac = gnutls_mac_get(session);
 827 kx = gnutls_kx_get(session);
 828
 829 string_format(cipherbuf, sizeof(cipherbuf), "%s:%s:%u", ver,
 830   gnutls_cipher_suite_get_name(kx, c, mac), bits);
 831 tls_cipher = cipherbuf;
 832
 833 DEBUG(D_tls) debug_printf("cipher: %s\n", cipherbuf);
 834 }
 835
 836
 837
 838 /*************************************************
 839 *       Start a TLS session in a server          *
 840 *************************************************/
 841
 842 /* This is called when Exim is running as a server, after having received
 843 the STARTTLS command. It must respond to that command, and then negotiate
 844 a TLS session.
 845
 846 Arguments:
 847   require_ciphers  list of allowed ciphers or NULL
 848   require_mac      list of allowed MACs or NULL
 849   require_kx       list of allowed key_exchange methods or NULL
 850   require_proto    list of allowed protocols or NULL
 851
 852 Returns:           OK on success
 853                    DEFER for errors before the start of the negotiation
 854                    FAIL for errors during the negotation; the server can't
 855                      continue running.
 856 */
 857
 858 int
 859 tls_server_start(uschar *require_ciphers, uschar *require_mac,
 860   uschar *require_kx, uschar *require_proto)
 861 {
 862 int rc;
 863 const char *error;
 864 uschar *expciphers = NULL;
 865 uschar *expmac = NULL;
 866 uschar *expkx = NULL;
 867 uschar *expproto = NULL;
 868
 869 /* Check for previous activation */
 870
 871 if (tls_active >= 0)
 872   {
 873   tls_error("STARTTLS received after TLS started", NULL, "");
 874   smtp_printf("554 Already in TLS\r\n");
 875   return FAIL;
 876   }
 877
 878 /* Initialize the library. If it fails, it will already have logged the error
 879 and sent an SMTP response. */
 880
 881 DEBUG(D_tls) debug_printf("initializing GnuTLS as a server\n");
 882
 883 rc = tls_init(NULL, tls_certificate, tls_privatekey, tls_verify_certificates,
 884   tls_crl);
 885 if (rc != OK) return rc;
 886
 887 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers) ||
 888     !expand_check(require_mac, US"gnutls_require_mac", &expmac) ||
 889     !expand_check(require_kx, US"gnutls_require_kx", &expkx) ||
 890     !expand_check(require_proto, US"gnutls_require_proto", &expproto))
 891   return FAIL;
 892
 893 /* If this is a host for which certificate verification is mandatory or
 894 optional, set up appropriately. */
 895
 896 tls_certificate_verified = FALSE;
 897 verify_requirement = VERIFY_NONE;
 898
 899 if (verify_check_host(&tls_verify_hosts) == OK)
 900   verify_requirement = VERIFY_REQUIRED;
 901 else if (verify_check_host(&tls_try_verify_hosts) == OK)
 902   verify_requirement = VERIFY_OPTIONAL;
 903
 904 /* Prepare for new connection */
 905
 906 tls_session = tls_session_init(GNUTLS_SERVER, expciphers, expmac, expkx,
 907   expproto);
 908 if (tls_session == NULL)
 909   return tls_error(US"tls_session_init", NULL,
 910     gnutls_strerror(GNUTLS_E_MEMORY_ERROR));
 911
 912 /* Set context and tell client to go ahead, except in the case of TLS startup
 913 on connection, where outputting anything now upsets the clients and tends to
 914 make them disconnect. We need to have an explicit fflush() here, to force out
 915 the response. Other smtp_printf() calls do not need it, because in non-TLS
 916 mode, the fflush() happens when smtp_getc() is called. */
 917
 918 if (!tls_on_connect)
 919   {
 920   smtp_printf("220 TLS go ahead\r\n");
 921   fflush(smtp_out);
 922   }
 923
 924 /* Now negotiate the TLS session. We put our own timer on it, since it seems
 925 that the GnuTLS library doesn't. */
 926
 927 gnutls_transport_set_ptr2(tls_session, (gnutls_transport_ptr)fileno(smtp_in),
 928                                        (gnutls_transport_ptr)fileno(smtp_out));
 929
 930 sigalrm_seen = FALSE;
 931 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
 932 rc = gnutls_handshake(tls_session);
 933 alarm(0);
 934
 935 if (rc < 0)
 936   {
 937   tls_error(US"gnutls_handshake", NULL,
 938     sigalrm_seen ? "timed out" : gnutls_strerror(rc));
 939
 940   /* It seems that, except in the case of a timeout, we have to close the
 941   connection right here; otherwise if the other end is running OpenSSL it hangs
 942   until the server times out. */
 943
 944   if (!sigalrm_seen)
 945     {
 946     (void)fclose(smtp_out);
 947     (void)fclose(smtp_in);
 948     }
 949
 950   return FAIL;
 951   }
 952
 953 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
 954
 955 if (verify_requirement != VERIFY_NONE &&
 956      !verify_certificate(tls_session, &error))
 957   {
 958   tls_error(US"certificate verification failed", NULL, error);
 959   return FAIL;
 960   }
 961
 962 construct_cipher_name(tls_session);
 963
 964 /* TLS has been set up. Adjust the input functions to read via TLS,
 965 and initialize appropriately. */
 966
 967 ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
 968 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
 969 ssl_xfer_eof = ssl_xfer_error = 0;
 970
 971 receive_getc = tls_getc;
 972 receive_ungetc = tls_ungetc;
 973 receive_feof = tls_feof;
 974 receive_ferror = tls_ferror;
 975 receive_smtp_buffered = tls_smtp_buffered;
 976
 977 tls_active = fileno(smtp_out);
 978
 979 return OK;
 980 }
 981
 982
 983
 984
 985 /*************************************************
 986 *    Start a TLS session in a client             *
 987 *************************************************/
 988
 989 /* Called from the smtp transport after STARTTLS has been accepted.
 990
 991 Arguments:
 992   fd                the fd of the connection
 993   host              connected host (for messages)
 994   addr              the first address (not used)
 995   dhparam           DH parameter file
 996   certificate       certificate file
 997   privatekey        private key file
 998   verify_certs      file for certificate verify
 999   verify_crl        CRL for verify
1000   require_ciphers   list of allowed ciphers or NULL
1001   require_mac       list of allowed MACs or NULL
1002   require_kx        list of allowed key_exchange methods or NULL
1003   require_proto     list of allowed protocols or NULL
1004   timeout           startup timeout
1005
1006 Returns:            OK/DEFER/FAIL (because using common functions),
1007                     but for a client, DEFER and FAIL have the same meaning
1008 */
1009
1010 int
1011 tls_client_start(int fd, host_item *host, address_item *addr, uschar *dhparam,
1012   uschar *certificate, uschar *privatekey, uschar *verify_certs,
1013   uschar *verify_crl, uschar *require_ciphers, uschar *require_mac,
1014   uschar *require_kx, uschar *require_proto, int timeout)
1015 {
1016 const gnutls_datum *server_certs;
1017 uschar *expciphers = NULL;
1018 uschar *expmac = NULL;
1019 uschar *expkx = NULL;
1020 uschar *expproto = NULL;
1021 const char *error;
1022 unsigned int server_certs_size;
1023 int rc;
1024
1025 DEBUG(D_tls) debug_printf("initializing GnuTLS as a client\n");
1026
1027 verify_requirement = (verify_certs == NULL)? VERIFY_NONE : VERIFY_REQUIRED;
1028 rc = tls_init(host, certificate, privatekey, verify_certs, verify_crl);
1029 if (rc != OK) return rc;
1030
1031 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers) ||
1032     !expand_check(require_mac, US"gnutls_require_mac", &expmac) ||
1033     !expand_check(require_kx, US"gnutls_require_kx", &expkx) ||
1034     !expand_check(require_proto, US"gnutls_require_proto", &expproto))
1035   return FAIL;
1036
1037 tls_session = tls_session_init(GNUTLS_CLIENT, expciphers, expmac, expkx,
1038   expproto);
1039
1040 if (tls_session == NULL)
1041   return tls_error(US "tls_session_init", host,
1042     gnutls_strerror(GNUTLS_E_MEMORY_ERROR));
1043
1044 gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr)fd);
1045
1046 /* There doesn't seem to be a built-in timeout on connection. */
1047
1048 sigalrm_seen = FALSE;
1049 alarm(timeout);
1050 rc = gnutls_handshake(tls_session);
1051 alarm(0);
1052
1053 if (rc < 0)
1054   return tls_error(US "gnutls_handshake", host,
1055     sigalrm_seen ? "timed out" : gnutls_strerror(rc));
1056
1057 server_certs = gnutls_certificate_get_peers(tls_session, &server_certs_size);
1058
1059 if (server_certs != NULL)
1060   {
1061   uschar buff[1024];
1062   gnutls_x509_crt gcert;
1063
1064   gnutls_x509_crt_init(&gcert);
1065   tls_peerdn = US"unknown";
1066
1067   if (gnutls_x509_crt_import(gcert, server_certs, GNUTLS_X509_FMT_DER) == 0)
1068     {
1069     size_t bufsize = sizeof(buff);
1070     if (gnutls_x509_crt_get_dn(gcert, CS buff, &bufsize) >= 0)
1071       tls_peerdn = string_copy_malloc(buff);
1072     }
1073   }
1074
1075 /* Should we also verify the hostname here? */
1076
1077 if (verify_requirement != VERIFY_NONE &&
1078       !verify_certificate(tls_session, &error))
1079   return tls_error(US"certificate verification failed", host, error);
1080
1081 construct_cipher_name(tls_session);    /* Sets tls_cipher */
1082 tls_active = fd;
1083 return OK;
1084 }
1085
1086
1087
1088 /*************************************************
1089 *    Deal with logging errors during I/O         *
1090 *************************************************/
1091
1092 /* We have to get the identity of the peer from saved data.
1093
1094 Argument:
1095   ec       the GnuTLS error code, or 0 if it's a local error
1096   when     text identifying read or write
1097   text     local error text when ec is 0
1098
1099 Returns:   nothing
1100 */
1101
1102 static void
1103 record_io_error(int ec, uschar *when, uschar *text)
1104 {
1105 const char *msg;
1106
1107 if (ec == GNUTLS_E_FATAL_ALERT_RECEIVED)
1108   msg = string_sprintf("%s: %s", gnutls_strerror(ec),
1109     gnutls_alert_get_name(gnutls_alert_get(tls_session)));
1110 else
1111   msg = gnutls_strerror(ec);
1112
1113 tls_error(when, client_host, msg);
1114 }
1115
1116
1117
1118 /*************************************************
1119 *            TLS version of getc                 *
1120 *************************************************/
1121
1122 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1123 it refills the buffer via the GnuTLS reading function.
1124
1125 Arguments:  none
1126 Returns:    the next character or EOF
1127 */
1128
1129 int
1130 tls_getc(void)
1131 {
1132 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
1133   {
1134   int inbytes;
1135
1136   DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%lx, %lx, %u)\n",
1137     (long) tls_session, (long) ssl_xfer_buffer, ssl_xfer_buffer_size);
1138
1139   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1140   inbytes = gnutls_record_recv(tls_session, CS ssl_xfer_buffer,
1141     ssl_xfer_buffer_size);
1142   alarm(0);
1143
1144   /* A zero-byte return appears to mean that the TLS session has been
1145      closed down, not that the socket itself has been closed down. Revert to
1146      non-TLS handling. */
1147
1148   if (inbytes == 0)
1149     {
1150     DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1151
1152     receive_getc = smtp_getc;
1153     receive_ungetc = smtp_ungetc;
1154     receive_feof = smtp_feof;
1155     receive_ferror = smtp_ferror;
1156     receive_smtp_buffered = smtp_buffered;
1157
1158     gnutls_deinit(tls_session);
1159     tls_session = NULL;
1160     tls_active = -1;
1161     tls_cipher = NULL;
1162     tls_peerdn = NULL;
1163
1164     return smtp_getc();
1165     }
1166
1167   /* Handle genuine errors */
1168
1169   else if (inbytes < 0)
1170     {
1171     record_io_error(inbytes, US"recv", NULL);
1172     ssl_xfer_error = 1;
1173     return EOF;
1174     }
1175 #ifndef DISABLE_DKIM
1176   dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
1177 #endif
1178   ssl_xfer_buffer_hwm = inbytes;
1179   ssl_xfer_buffer_lwm = 0;
1180   }
1181
1182
1183 /* Something in the buffer; return next uschar */
1184
1185 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
1186 }
1187
1188
1189
1190 /*************************************************
1191 *          Read bytes from TLS channel           *
1192 *************************************************/
1193
1194 /*
1195 Arguments:
1196   buff      buffer of data
1197   len       size of buffer
1198
1199 Returns:    the number of bytes read
1200             -1 after a failed read
1201 */
1202
1203 int
1204 tls_read(uschar *buff, size_t len)
1205 {
1206 int inbytes;
1207
1208 DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%lx, %lx, %u)\n",
1209   (long) tls_session, (long) buff, len);
1210
1211 inbytes = gnutls_record_recv(tls_session, CS buff, len);
1212 if (inbytes > 0) return inbytes;
1213 if (inbytes == 0)
1214   {
1215   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1216   }
1217 else record_io_error(inbytes, US"recv", NULL);
1218
1219 return -1;
1220 }
1221
1222
1223
1224 /*************************************************
1225 *         Write bytes down TLS channel           *
1226 *************************************************/
1227
1228 /*
1229 Arguments:
1230   buff      buffer of data
1231   len       number of bytes
1232
1233 Returns:    the number of bytes after a successful write,
1234             -1 after a failed write
1235 */
1236
1237 int
1238 tls_write(const uschar *buff, size_t len)
1239 {
1240 int outbytes;
1241 int left = len;
1242
1243 DEBUG(D_tls) debug_printf("tls_do_write(%lx, %d)\n", (long) buff, left);
1244 while (left > 0)
1245   {
1246   DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %lx, %d)\n", (long)buff,
1247     left);
1248   outbytes = gnutls_record_send(tls_session, CS buff, left);
1249
1250   DEBUG(D_tls) debug_printf("outbytes=%d\n", outbytes);
1251   if (outbytes < 0)
1252     {
1253     record_io_error(outbytes, US"send", NULL);
1254     return -1;
1255     }
1256   if (outbytes == 0)
1257     {
1258     record_io_error(0, US"send", US"TLS channel closed on write");
1259     return -1;
1260     }
1261
1262   left -= outbytes;
1263   buff += outbytes;
1264   }
1265
1266 return len;
1267 }
1268
1269
1270
1271 /*************************************************
1272 *         Close down a TLS session               *
1273 *************************************************/
1274
1275 /* This is also called from within a delivery subprocess forked from the
1276 daemon, to shut down the TLS library, without actually doing a shutdown (which
1277 would tamper with the TLS session in the parent process).
1278
1279 Arguments:   TRUE if gnutls_bye is to be called
1280 Returns:     nothing
1281 */
1282
1283 void
1284 tls_close(BOOL shutdown)
1285 {
1286 if (tls_active < 0) return;  /* TLS was not active */
1287
1288 if (shutdown)
1289   {
1290   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS\n");
1291   gnutls_bye(tls_session, GNUTLS_SHUT_WR);
1292   }
1293
1294 gnutls_deinit(tls_session);
1295 tls_session = NULL;
1296 gnutls_global_deinit();
1297
1298 tls_active = -1;
1299 }
1300
1301 /* End of tls-gnu.c */