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