src/src/tls.c

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