src/src/tls.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8
   9 /* This module provides TLS (aka SSL) support for Exim. The code for OpenSSL is
  10 based on a patch that was originally contributed by Steve Haslam. It was
  11 adapted from stunnel, a GPL program by Michal Trojnara. The code for GNU TLS is
  12 based on a patch contributed by Nikos Mavrogiannopoulos. Because these packages
  13 are so very different, the functions for each are kept in separate files. The
  14 relevant file is #included as required, after any any common functions.
  15
  16 No cryptographic code is included in Exim. All this module does is to call
  17 functions from the OpenSSL or GNU TLS libraries. */
  18
  19
  20 #include "exim.h"
  21 #include "transports/smtp.h"
  22
  23 #if !defined(DISABLE_TLS) && !defined(USE_OPENSSL) && !defined(USE_GNUTLS)
  24 # error One of USE_OPENSSL or USE_GNUTLS must be defined for a TLS build
  25 #endif
  26
  27
  28 /* Forward decl. */
  29 static void tls_client_resmption_key(tls_support *, smtp_connect_args *,
  30   smtp_transport_options_block *);
  31
  32
  33 #if defined(MACRO_PREDEF) && !defined(DISABLE_TLS)
  34 # include "macro_predef.h"
  35 # ifdef USE_GNUTLS
  36 #  include "tls-gnu.c"
  37 # else
  38 #  include "tls-openssl.c"
  39 # endif
  40 #endif
  41
  42 #ifndef MACRO_PREDEF
  43
  44 static void tls_per_lib_daemon_init(void);
  45 static void tls_per_lib_daemon_tick(void);
  46 static unsigned  tls_server_creds_init(void);
  47 static void tls_server_creds_invalidate(void);
  48 static void tls_client_creds_init(transport_instance *, BOOL);
  49 static void tls_client_creds_invalidate(transport_instance *);
  50 static void tls_daemon_creds_reload(void);
  51 static BOOL opt_set_and_noexpand(const uschar *);
  52 static BOOL opt_unset_or_noexpand(const uschar *);
  53
  54
  55
  56 /* This module is compiled only when it is specifically requested in the
  57 build-time configuration. However, some compilers don't like compiling empty
  58 modules, so keep them happy with a dummy when skipping the rest. Make it
  59 reference itself to stop picky compilers complaining that it is unused, and put
  60 in a dummy argument to stop even pickier compilers complaining about infinite
  61 loops. */
  62
  63 #ifdef DISABLE_TLS
  64 static void dummy(int x) { dummy(x-1); }
  65 #else   /* most of the rest of the file */
  66
  67 const exim_tlslib_state null_tls_preload = {0};
  68
  69 /* Static variables that are used for buffering data by both sets of
  70 functions and the common functions below.
  71
  72 We're moving away from this; GnuTLS is already using a state, which
  73 can switch, so we can do TLS callouts during ACLs. */
  74
  75 static const int ssl_xfer_buffer_size = 4096;
  76 #ifdef USE_OPENSSL
  77 static uschar *ssl_xfer_buffer = NULL;
  78 static int ssl_xfer_buffer_lwm = 0;
  79 static int ssl_xfer_buffer_hwm = 0;
  80 static int ssl_xfer_eof = FALSE;
  81 static BOOL ssl_xfer_error = FALSE;
  82 #endif
  83
  84 #ifdef EXIM_HAVE_KEVENT
  85 # define KEV_SIZE 16    /* Eight file,dir pairs */
  86 static struct kevent kev[KEV_SIZE];
  87 static int kev_used = 0;
  88 #endif
  89
  90 static unsigned tls_creds_expire = 0;
  91
  92 /*************************************************
  93 *       Expand string; give error on failure     *
  94 *************************************************/
  95
  96 /* If expansion is forced to fail, set the result NULL and return TRUE.
  97 Other failures return FALSE. For a server, an SMTP response is given.
  98
  99 Arguments:
 100   s         the string to expand; if NULL just return TRUE
 101   name      name of string being expanded (for error)
 102   result    where to put the result
 103
 104 Returns:    TRUE if OK; result may still be NULL after forced failure
 105 */
 106
 107 static BOOL
 108 expand_check(const uschar *s, const uschar *name, uschar **result, uschar ** errstr)
 109 {
 110 if (!s)
 111   *result = NULL;
 112 else if (  !(*result = expand_string(US s)) /* need to clean up const more */
 113         && !f.expand_string_forcedfail
 114         )
 115   {
 116   *errstr = US"Internal error";
 117   log_write(0, LOG_MAIN|LOG_PANIC, "expansion of %s failed: %s", name,
 118     expand_string_message);
 119   return FALSE;
 120   }
 121 return TRUE;
 122 }
 123
 124
 125 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
 126 /* Add the directory for a filename to the inotify handle, creating that if
 127 needed.  This is enough to see changes to files in that dir.
 128 Return boolean success.
 129
 130 The word "system" fails, which is on the safe side as we don't know what
 131 directory it implies nor if the TLS library handles a watch for us.
 132
 133 The string "system,cache" is recognised and explicitly accepted without
 134 setting a watch.  This permits the system CA bundle to be cached even though
 135 we have no way to tell when it gets modified by an update.
 136 The call chain for OpenSSL uses a (undocumented) call into the library
 137 to discover the actual file.  We don't know what GnuTLS uses.
 138
 139 A full set of caching including the CAs takes 35ms output off of the
 140 server tls_init() (GnuTLS, Fedora 32, 2018-class x86_64 laptop hardware).
 141 */
 142 static BOOL
 143 tls_set_one_watch(const uschar * filename)
 144 # ifdef EXIM_HAVE_INOTIFY
 145 {
 146 uschar buf[PATH_MAX];
 147 ssize_t len;
 148 uschar * s;
 149
 150 if (Ustrcmp(filename, "system,cache") == 0) return TRUE;
 151 if (!(s = Ustrrchr(filename, '/'))) return FALSE;
 152
 153 for (unsigned loop = 20;
 154      (len = readlink(CCS filename, CS buf, sizeof(buf))) >= 0; )
 155   {                                             /* a symlink */
 156   if (--loop == 0) { errno = ELOOP; return FALSE; }
 157   filename = buf[0] == '/'
 158     ? string_copyn(buf, (unsigned)len)  /* mem released by tls_set_watch */
 159     : string_sprintf("%.*s/%.*s", (int)(s - filename), (int)len);
 160   s = Ustrrchr(filename, '/');
 161   }
 162 if (errno != EINVAL)
 163   return FALSE;                                 /* other error */
 164
 165 /* not a symlink */
 166 s = string_copyn(filename, s - filename);       /* mem released by tls_set_watch */
 167
 168 DEBUG(D_tls) debug_printf("watch dir '%s'\n", s);
 169
 170 if (inotify_add_watch(tls_watch_fd, CCS s,
 171       IN_ONESHOT | IN_CLOSE_WRITE | IN_DELETE | IN_DELETE_SELF
 172       | IN_MOVED_FROM | IN_MOVED_TO | IN_MOVE_SELF) >= 0)
 173   return TRUE;
 174 DEBUG(D_tls) debug_printf("notify_add_watch: %s\n", strerror(errno));
 175 return FALSE;
 176 }
 177 # endif
 178 # ifdef EXIM_HAVE_KEVENT
 179 {
 180 uschar * s, * t;
 181 int fd1, fd2, i, j, cnt = 0;
 182 struct stat sb;
 183 #ifdef OpenBSD
 184 struct kevent k_dummy;
 185 struct timespec ts = {0};
 186 #endif
 187
 188 errno = 0;
 189 if (Ustrcmp(filename, "system,cache") == 0) return TRUE;
 190
 191 for (;;)
 192   {
 193   if (kev_used > KEV_SIZE-2) { s = US"out of kev space"; goto bad; }
 194   if (!(s = Ustrrchr(filename, '/'))) return FALSE;
 195   s = string_copyn(filename, s - filename);     /* mem released by tls_set_watch */
 196
 197   /* The dir open will fail if there is a symlink on the path. Fine; it's too
 198   much effort to handle all possible cases; just refuse the preload. */
 199
 200   if ((fd2 = open(CCS s, O_RDONLY | O_NOFOLLOW)) < 0) { s = US"open dir"; goto bad; }
 201
 202   if ((lstat(CCS filename, &sb)) < 0) { s = US"lstat"; goto bad; }
 203   if (!S_ISLNK(sb.st_mode))
 204     {
 205     if ((fd1 = open(CCS filename, O_RDONLY | O_NOFOLLOW)) < 0)
 206       { s = US"open file"; goto bad; }
 207     DEBUG(D_tls) debug_printf("watch file '%s':\t%d\n", filename, fd1);
 208     EV_SET(&kev[kev_used++],
 209         (uintptr_t)fd1,
 210         EVFILT_VNODE,
 211         EV_ADD | EV_ENABLE | EV_ONESHOT,
 212         NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND
 213         | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE,
 214         0,
 215         NULL);
 216     cnt++;
 217     }
 218   DEBUG(D_tls) debug_printf("watch dir  '%s':\t%d\n", s, fd2);
 219   EV_SET(&kev[kev_used++],
 220         (uintptr_t)fd2,
 221         EVFILT_VNODE,
 222         EV_ADD | EV_ENABLE | EV_ONESHOT,
 223         NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND
 224         | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE,
 225         0,
 226         NULL);
 227   cnt++;
 228
 229   if (!(S_ISLNK(sb.st_mode))) break;
 230
 231   t = store_get(1024, GET_UNTAINTED);
 232   Ustrncpy(t, s, 1022);
 233   j = Ustrlen(s);
 234   t[j++] = '/';
 235   if ((i = readlink(CCS filename, (void *)(t+j), 1023-j)) < 0) { s = US"readlink"; goto bad; }
 236   filename = t;
 237   *(t += i+j) = '\0';
 238   store_release_above(t+1);
 239   }
 240
 241 #ifdef OpenBSD
 242 if (kevent(tls_watch_fd, &kev[kev_used-cnt], cnt, &k_dummy, 1, &ts) >= 0)
 243   return TRUE;
 244 #else
 245 if (kevent(tls_watch_fd, &kev[kev_used-cnt], cnt, NULL, 0, NULL) >= 0)
 246   return TRUE;
 247 #endif
 248 s = US"kevent";
 249
 250 bad:
 251 DEBUG(D_tls)
 252   if (errno)
 253     debug_printf("%s: %s: %s\n", __FUNCTION__, s, strerror(errno));
 254   else
 255     debug_printf("%s: %s\n", __FUNCTION__, s);
 256 return FALSE;
 257 }
 258 # endif /*EXIM_HAVE_KEVENT*/
 259
 260
 261 /* Create an inotify facility if needed.
 262 Then set watches on the dir containing the given file or (optionally)
 263 list of files.  Return boolean success. */
 264
 265 static BOOL
 266 tls_set_watch(const uschar * filename, BOOL list)
 267 {
 268 rmark r;
 269 BOOL rc = FALSE;
 270
 271 if (!filename || !*filename) return TRUE;
 272 if (Ustrncmp(filename, "system", 6) == 0) return TRUE;
 273
 274 DEBUG(D_tls) debug_printf("tls_set_watch: '%s'\n", filename);
 275
 276 if (  tls_watch_fd < 0
 277 # ifdef EXIM_HAVE_INOTIFY
 278    && (tls_watch_fd = inotify_init1(O_CLOEXEC)) < 0
 279 # endif
 280 # ifdef EXIM_HAVE_KEVENT
 281    && (tls_watch_fd = kqueue()) < 0
 282 # endif
 283    )
 284     {
 285     DEBUG(D_tls) debug_printf("inotify_init: %s\n", strerror(errno));
 286     return FALSE;
 287     }
 288
 289 r = store_mark();
 290
 291 if (list)
 292   {
 293   int sep = 0;
 294   for (uschar * s; s = string_nextinlist(&filename, &sep, NULL, 0); )
 295     if (!(rc = tls_set_one_watch(s))) break;
 296   }
 297 else
 298   rc = tls_set_one_watch(filename);
 299
 300 store_reset(r);
 301 if (!rc) DEBUG(D_tls) debug_printf("tls_set_watch() fail on '%s': %s\n", filename, strerror(errno));
 302 return rc;
 303 }
 304
 305
 306 void
 307 tls_watch_discard_event(int fd)
 308 {
 309 #ifdef EXIM_HAVE_INOTIFY
 310 (void) read(fd, big_buffer, big_buffer_size);
 311 #endif
 312 #ifdef EXIM_HAVE_KEVENT
 313 struct kevent kev;
 314 struct timespec t = {0};
 315 (void) kevent(fd, NULL, 0, &kev, 1, &t);
 316 #endif
 317 }
 318 #endif  /*EXIM_HAVE_INOTIFY*/
 319
 320
 321 void
 322 tls_client_creds_reload(BOOL watch)
 323 {
 324 for(transport_instance * t = transports; t; t = t->next)
 325   if (Ustrcmp(t->driver_name, "smtp") == 0)
 326     {
 327     tls_client_creds_invalidate(t);
 328     tls_client_creds_init(t, watch);
 329     }
 330 }
 331
 332
 333 void
 334 tls_watch_invalidate(void)
 335 {
 336 if (tls_watch_fd < 0) return;
 337
 338 #ifdef EXIM_HAVE_KEVENT
 339 /* Close the files we had open for kevent */
 340 for (int i = 0; i < kev_used; i++)
 341   {
 342   DEBUG(D_tls) debug_printf("closing watch fd: %d\n", (int) kev[i].ident);
 343   (void) close((int) kev[i].ident);
 344   kev[i].ident = (uintptr_t)-1;
 345   }
 346 kev_used = 0;
 347 #endif
 348
 349 close(tls_watch_fd);
 350 tls_watch_fd = -1;
 351 }
 352
 353
 354 static void
 355 tls_daemon_creds_reload(void)
 356 {
 357 unsigned lifetime;
 358
 359 #ifdef EXIM_HAVE_KEVENT
 360 tls_watch_invalidate();
 361 #endif
 362
 363 tls_server_creds_invalidate();
 364 tls_creds_expire = (lifetime = tls_server_creds_init())
 365   ? time(NULL) + lifetime : 0;
 366
 367 tls_client_creds_reload(TRUE);
 368 }
 369
 370
 371 /* Utility predicates for use by the per-library code */
 372 static BOOL
 373 opt_set_and_noexpand(const uschar * opt)
 374 { return opt && *opt && Ustrchr(opt, '$') == NULL; }
 375
 376 static BOOL
 377 opt_unset_or_noexpand(const uschar * opt)
 378 { return !opt || Ustrchr(opt, '$') == NULL; }
 379
 380
 381
 382 /* Called every time round the daemon loop.
 383
 384 If we reloaded fd-watcher, return the old watch fd
 385 having modified the global for the new one. Otherwise
 386 return -1.
 387 */
 388
 389 int
 390 tls_daemon_tick(void)
 391 {
 392 int old_watch_fd = tls_watch_fd;
 393
 394 tls_per_lib_daemon_tick();
 395 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
 396 if (tls_creds_expire && time(NULL) >= tls_creds_expire)
 397   {
 398   /* The server cert is a selfsign, with limited lifetime.  Dump it and
 399   generate a new one.  Reload the rest of the creds also as the machinery
 400   is all there. */
 401
 402   DEBUG(D_tls) debug_printf("selfsign cert rotate\n");
 403   tls_creds_expire = 0;
 404   tls_daemon_creds_reload();
 405   return old_watch_fd;
 406   }
 407 else if (tls_watch_trigger_time && time(NULL) >= tls_watch_trigger_time + 5)
 408   {
 409   /* Called, after a delay for multiple file ops to get done, from
 410   the daemon when any of the watches added (above) fire.
 411   Dump the set of watches and arrange to reload cached creds (which
 412   will set up new watches). */
 413
 414   DEBUG(D_tls) debug_printf("watch triggered\n");
 415   tls_watch_trigger_time = tls_creds_expire = 0;
 416   tls_daemon_creds_reload();
 417   return old_watch_fd;
 418   }
 419 #endif
 420 return -1;
 421 }
 422
 423 /* Called once at daemon startup */
 424
 425 void
 426 tls_daemon_init(void)
 427 {
 428 tls_per_lib_daemon_init();
 429 }
 430
 431
 432 /*************************************************
 433 *        Timezone environment flipping           *
 434 *************************************************/
 435
 436 static uschar *
 437 to_tz(uschar * tz)
 438 {
 439 uschar * old = US getenv("TZ");
 440 (void) setenv("TZ", CCS tz, 1);
 441 tzset();
 442 return old;
 443 }
 444
 445 static void
 446 restore_tz(uschar * tz)
 447 {
 448 if (tz)
 449   (void) setenv("TZ", CCS tz, 1);
 450 else
 451   (void) os_unsetenv(US"TZ");
 452 tzset();
 453 }
 454
 455 /*************************************************
 456 *        Many functions are package-specific     *
 457 *************************************************/
 458
 459 #ifdef USE_GNUTLS
 460 # include "tls-gnu.c"
 461 # include "tlscert-gnu.c"
 462 # define ssl_xfer_buffer (state_server.xfer_buffer)
 463 # define ssl_xfer_buffer_lwm (state_server.xfer_buffer_lwm)
 464 # define ssl_xfer_buffer_hwm (state_server.xfer_buffer_hwm)
 465 # define ssl_xfer_eof (state_server.xfer_eof)
 466 # define ssl_xfer_error (state_server.xfer_error)
 467 #endif
 468
 469 #ifdef USE_OPENSSL
 470 # include "tls-openssl.c"
 471 # include "tlscert-openssl.c"
 472 #endif
 473
 474
 475
 476 /*************************************************
 477 *           TLS version of ungetc                *
 478 *************************************************/
 479
 480 /* Puts a character back in the input buffer. Only ever
 481 called once.
 482 Only used by the server-side TLS.
 483
 484 Arguments:
 485   ch           the character
 486
 487 Returns:       the character
 488 */
 489
 490 int
 491 tls_ungetc(int ch)
 492 {
 493 if (ssl_xfer_buffer_lwm <= 0)
 494   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "buffer underflow in tls_ungetc");
 495
 496 ssl_xfer_buffer[--ssl_xfer_buffer_lwm] = ch;
 497 return ch;
 498 }
 499
 500
 501
 502 /*************************************************
 503 *           TLS version of feof                  *
 504 *************************************************/
 505
 506 /* Tests for a previous EOF
 507 Only used by the server-side TLS.
 508
 509 Arguments:     none
 510 Returns:       non-zero if the eof flag is set
 511 */
 512
 513 int
 514 tls_feof(void)
 515 {
 516 return (int)ssl_xfer_eof;
 517 }
 518
 519
 520
 521 /*************************************************
 522 *              TLS version of ferror             *
 523 *************************************************/
 524
 525 /* Tests for a previous read error, and returns with errno
 526 restored to what it was when the error was detected.
 527 Only used by the server-side TLS.
 528
 529 >>>>> Hmm. Errno not handled yet. Where do we get it from?  >>>>>
 530
 531 Arguments:     none
 532 Returns:       non-zero if the error flag is set
 533 */
 534
 535 int
 536 tls_ferror(void)
 537 {
 538 return (int)ssl_xfer_error;
 539 }
 540
 541
 542 /*************************************************
 543 *           TLS version of smtp_buffered         *
 544 *************************************************/
 545
 546 /* Tests for unused chars in the TLS input buffer.
 547 Only used by the server-side TLS.
 548
 549 Arguments:     none
 550 Returns:       TRUE/FALSE
 551 */
 552
 553 BOOL
 554 tls_smtp_buffered(void)
 555 {
 556 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
 557 }
 558
 559
 560 #endif  /*DISABLE_TLS*/
 561
 562 void
 563 tls_modify_variables(tls_support * dest_tsp)
 564 {
 565 modify_variable(US"tls_bits",                 &dest_tsp->bits);
 566 modify_variable(US"tls_certificate_verified", &dest_tsp->certificate_verified);
 567 modify_variable(US"tls_cipher",               &dest_tsp->cipher);
 568 modify_variable(US"tls_peerdn",               &dest_tsp->peerdn);
 569 #ifdef USE_OPENSSL
 570 modify_variable(US"tls_sni",                  &dest_tsp->sni);
 571 #endif
 572 }
 573
 574
 575 #ifndef DISABLE_TLS
 576 /************************************************
 577 *       TLS certificate name operations         *
 578 ************************************************/
 579
 580 /* Convert an rfc4514 DN to an exim comma-sep list.
 581 Backslashed commas need to be replaced by doublecomma
 582 for Exim's list quoting.  We modify the given string
 583 inplace.
 584 */
 585
 586 static void
 587 dn_to_list(uschar * dn)
 588 {
 589 for (uschar * cp = dn; *cp; cp++)
 590   if (cp[0] == '\\' && cp[1] == ',')
 591     *cp++ = ',';
 592 }
 593
 594
 595 /* Extract fields of a given type from an RFC4514-
 596 format Distinguished Name.  Return an Exim list.
 597 NOTE: We modify the supplied dn string during operation.
 598
 599 Arguments:
 600         dn      Distinguished Name string
 601         mod     list containing optional output list-sep and
 602                 field selector match, comma-separated
 603 Return:
 604         allocated string with list of matching fields,
 605         field type stripped
 606 */
 607
 608 uschar *
 609 tls_field_from_dn(uschar * dn, const uschar * mod)
 610 {
 611 int insep = ',';
 612 uschar outsep = '\n';
 613 uschar * ele;
 614 uschar * match = NULL;
 615 int len;
 616 gstring * list = NULL;
 617
 618 while ((ele = string_nextinlist(&mod, &insep, NULL, 0)))
 619   if (ele[0] != '>')
 620     match = ele;        /* field tag to match */
 621   else if (ele[1])
 622     outsep = ele[1];    /* nondefault output separator */
 623
 624 dn_to_list(dn);
 625 insep = ',';
 626 len = match ? Ustrlen(match) : -1;
 627 while ((ele = string_nextinlist(CUSS &dn, &insep, NULL, 0)))
 628   if (  !match
 629      || Ustrncmp(ele, match, len) == 0 && ele[len] == '='
 630      )
 631     list = string_append_listele(list, outsep, ele+len+1);
 632 return string_from_gstring(list);
 633 }
 634
 635
 636 /* Compare a domain name with a possibly-wildcarded name. Wildcards
 637 are restricted to a single one, as the first element of patterns
 638 having at least three dot-separated elements.  Case-independent.
 639 Return TRUE for a match
 640 */
 641 static BOOL
 642 is_name_match(const uschar * name, const uschar * pat)
 643 {
 644 uschar * cp;
 645 return *pat == '*'              /* possible wildcard match */
 646   ?    *++pat == '.'            /* starts star, dot              */
 647     && !Ustrchr(++pat, '*')     /* has no more stars             */
 648     && Ustrchr(pat, '.')        /* and has another dot.          */
 649     && (cp = Ustrchr(name, '.'))/* The name has at least one dot */
 650     && strcmpic(++cp, pat) == 0 /* and we only compare after it. */
 651   :    !Ustrchr(pat+1, '*')
 652     && strcmpic(name, pat) == 0;
 653 }
 654
 655 /* Compare a list of names with the dnsname elements
 656 of the Subject Alternate Name, if any, and the
 657 Subject otherwise.
 658
 659 Arguments:
 660         namelist names to compare
 661         cert     certificate
 662
 663 Returns:
 664         TRUE/FALSE
 665 */
 666
 667 BOOL
 668 tls_is_name_for_cert(const uschar * namelist, void * cert)
 669 {
 670 uschar * altnames = tls_cert_subject_altname(cert, US"dns");
 671 uschar * subjdn;
 672 uschar * certname;
 673 int cmp_sep = 0;
 674 uschar * cmpname;
 675
 676 if ((altnames = tls_cert_subject_altname(cert, US"dns")))
 677   {
 678   int alt_sep = '\n';
 679   while ((cmpname = string_nextinlist(&namelist, &cmp_sep, NULL, 0)))
 680     {
 681     const uschar * an = altnames;
 682     while ((certname = string_nextinlist(&an, &alt_sep, NULL, 0)))
 683       if (is_name_match(cmpname, certname))
 684         return TRUE;
 685     }
 686   }
 687
 688 else if ((subjdn = tls_cert_subject(cert, NULL)))
 689   {
 690   int sn_sep = ',';
 691
 692   dn_to_list(subjdn);
 693   while ((cmpname = string_nextinlist(&namelist, &cmp_sep, NULL, 0)))
 694     {
 695     const uschar * sn = subjdn;
 696     while ((certname = string_nextinlist(&sn, &sn_sep, NULL, 0)))
 697       if (  *certname++ == 'C'
 698          && *certname++ == 'N'
 699          && *certname++ == '='
 700          && is_name_match(cmpname, certname)
 701          )
 702         return TRUE;
 703     }
 704   }
 705 return FALSE;
 706 }
 707
 708 /* Environment cleanup: The GnuTLS library uses SSLKEYLOGFILE in the environment
 709 and writes a file by that name.  Our OpenSSL code does the same, using keying
 710 info from the library API.
 711 The GnuTLS support only works if exim is run by root, not taking advantage of
 712 the setuid bit.
 713 You can use either the external environment (modulo the keep_environment config)
 714 or the add_environment config option for SSLKEYLOGFILE; the latter takes
 715 precedence.
 716
 717 If the path is absolute, require it starts with the spooldir; otherwise delete
 718 the env variable.  If relative, prefix the spooldir.
 719 */
 720 void
 721 tls_clean_env(void)
 722 {
 723 uschar * path = US getenv("SSLKEYLOGFILE");
 724 if (path)
 725   if (!*path)
 726     unsetenv("SSLKEYLOGFILE");
 727   else if (*path != '/')
 728     {
 729     DEBUG(D_tls)
 730       debug_printf("prepending spooldir to  env SSLKEYLOGFILE\n");
 731     setenv("SSLKEYLOGFILE", CCS string_sprintf("%s/%s", spool_directory, path), 1);
 732     }
 733   else if (Ustrncmp(path, spool_directory, Ustrlen(spool_directory)) != 0)
 734     {
 735     DEBUG(D_tls)
 736       debug_printf("removing env SSLKEYLOGFILE=%s: not under spooldir\n", path);
 737     unsetenv("SSLKEYLOGFILE");
 738     }
 739 }
 740
 741 /*************************************************
 742 *       Drop privs for checking TLS config      *
 743 *************************************************/
 744
 745 /* We want to validate TLS options during readconf, but do not want to be
 746 root when we call into the TLS library, in case of library linkage errors
 747 which cause segfaults; before this check, those were always done as the Exim
 748 runtime user and it makes sense to continue with that.
 749
 750 Assumes:  tls_require_ciphers has been set, if it will be
 751           exim_user has been set, if it will be
 752           exim_group has been set, if it will be
 753
 754 Returns:  bool for "okay"; false will cause caller to immediately exit.
 755 */
 756
 757 BOOL
 758 tls_dropprivs_validate_require_cipher(BOOL nowarn)
 759 {
 760 const uschar *errmsg;
 761 pid_t pid;
 762 int rc, status;
 763 void (*oldsignal)(int);
 764
 765 /* If TLS will never be used, no point checking ciphers */
 766
 767 if (  !tls_advertise_hosts
 768    || !*tls_advertise_hosts
 769    || Ustrcmp(tls_advertise_hosts, ":") == 0
 770    )
 771   return TRUE;
 772 else if (!nowarn && !tls_certificate)
 773   log_write(0, LOG_MAIN,
 774     "Warning: No server certificate defined; will use a selfsigned one.\n"
 775     " Suggested action: either install a certificate or change tls_advertise_hosts option");
 776
 777 oldsignal = signal(SIGCHLD, SIG_DFL);
 778
 779 fflush(NULL);
 780 if ((pid = exim_fork(US"cipher-validate")) < 0)
 781   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
 782
 783 if (pid == 0)
 784   {
 785   /* in some modes, will have dropped privilege already */
 786   if (!geteuid())
 787     exim_setugid(exim_uid, exim_gid, FALSE,
 788         US"calling tls_validate_require_cipher");
 789
 790   if ((errmsg = tls_validate_require_cipher()))
 791     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 792         "tls_require_ciphers invalid: %s", errmsg);
 793   fflush(NULL);
 794   exim_underbar_exit(EXIT_SUCCESS);
 795   }
 796
 797 do {
 798   rc = waitpid(pid, &status, 0);
 799 } while (rc < 0 && errno == EINTR);
 800
 801 DEBUG(D_tls)
 802   debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
 803       (int)pid, status);
 804
 805 signal(SIGCHLD, oldsignal);
 806
 807 return status == 0;
 808 }
 809
 810
 811
 812
 813 static void
 814 tls_client_resmption_key(tls_support * tlsp, smtp_connect_args * conn_args,
 815   smtp_transport_options_block * ob)
 816 {
 817 #ifndef DISABLE_TLS_RESUME
 818 hctx * h = &tlsp->resume_hctx;
 819 blob b;
 820 gstring * g;
 821
 822 DEBUG(D_tls) if (conn_args->host_lbserver)
 823   debug_printf("TLS: lbserver '%s'\n", conn_args->host_lbserver);
 824
 825 # ifdef EXIM_HAVE_SHA2
 826 exim_sha_init(h, HASH_SHA2_256);
 827 # else
 828 exim_sha_init(h, HASH_SHA1);
 829 # endif
 830 exim_sha_update_string(h, conn_args->host_lbserver);
 831 # ifdef SUPPORT_DANE
 832 if (conn_args->dane)
 833   exim_sha_update(h,  CUS &conn_args->tlsa_dnsa, sizeof(dns_answer));
 834 # endif
 835 exim_sha_update_string(h, conn_args->host->address);
 836 exim_sha_update(h,   CUS &conn_args->host->port, sizeof(conn_args->host->port));
 837 exim_sha_update_string(h, conn_args->sending_ip_address);
 838 exim_sha_update_string(h, openssl_options);
 839 exim_sha_update_string(h, ob->tls_require_ciphers);
 840 exim_sha_update_string(h, tlsp->sni);
 841 # ifdef EXIM_HAVE_ALPN
 842 exim_sha_update_string(h, ob->tls_alpn);
 843 # endif
 844 exim_sha_finish(h, &b);
 845 for (g = string_get(b.len*2+1); b.len-- > 0; )
 846   g = string_fmt_append(g, "%02x", *b.data++);
 847 tlsp->resume_index = string_from_gstring(g);
 848 DEBUG(D_tls) debug_printf("TLS: resume session index %s\n", tlsp->resume_index);
 849 #endif
 850 }
 851
 852 #endif  /*!DISABLE_TLS*/
 853 #endif  /*!MACRO_PREDEF*/
 854
 855 /* vi: aw ai sw=2
 856 */
 857 /* End of tls.c */