7b67bb7933ef94f013d1302a5d4e67bf098a5503
[exim.git] / src / src / tls-gnu.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) Phil Pennock 2012 */
7 /* Copyright (c) The Exim Maintainers 2020 - 2021 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10 /* This file provides TLS/SSL support for Exim using the GnuTLS library,
11 one of the available supported implementations.  This file is #included into
12 tls.c when USE_GNUTLS has been set.
13
14 The code herein is a revamp of GnuTLS integration using the current APIs; the
15 original tls-gnu.c was based on a patch which was contributed by Nikos
16 Mavrogiannopoulos.  The revamp is partially a rewrite, partially cut&paste as
17 appropriate.
18
19 APIs current as of GnuTLS 2.12.18; note that the GnuTLS manual is for GnuTLS 3,
20 which is not widely deployed by OS vendors.  Will note issues below, which may
21 assist in updating the code in the future.  Another sources of hints is
22 mod_gnutls for Apache (SNI callback registration and handling).
23
24 Keeping client and server variables more split than before and is currently
25 the norm, in anticipation of TLS in ACL callouts.
26
27 I wanted to switch to gnutls_certificate_set_verify_function() so that
28 certificate rejection could happen during handshake where it belongs, rather
29 than being dropped afterwards, but that was introduced in 2.10.0 and Debian
30 (6.0.5) is still on 2.8.6.  So for now we have to stick with sub-par behaviour.
31
32 (I wasn't looking for libraries quite that old, when updating to get rid of
33 compiler warnings of deprecated APIs.  If it turns out that a lot of the rest
34 require current GnuTLS, then we'll drop support for the ancient libraries).
35 */
36
37 #include <gnutls/gnutls.h>
38 /* needed for cert checks in verification and DN extraction: */
39 #include <gnutls/x509.h>
40 /* man-page is incorrect, gnutls_rnd() is not in gnutls.h: */
41 #include <gnutls/crypto.h>
42
43 /* needed to disable PKCS11 autoload unless requested */
44 #if GNUTLS_VERSION_NUMBER >= 0x020c00
45 # include <gnutls/pkcs11.h>
46 # define SUPPORT_PARAM_TO_PK_BITS
47 #endif
48 #if GNUTLS_VERSION_NUMBER < 0x030103 && !defined(DISABLE_OCSP)
49 # warning "GnuTLS library version too old; define DISABLE_OCSP in Makefile"
50 # define DISABLE_OCSP
51 #endif
52 #if GNUTLS_VERSION_NUMBER < 0x020a00 && !defined(DISABLE_EVENT)
53 # warning "GnuTLS library version too old; tls:cert event unsupported"
54 # define DISABLE_EVENT
55 #endif
56 #if GNUTLS_VERSION_NUMBER >= 0x030000
57 # define SUPPORT_SELFSIGN       /* Uncertain what version is first usable but 2.12.23 is not */
58 #endif
59 #if GNUTLS_VERSION_NUMBER >= 0x030306
60 # define SUPPORT_CA_DIR
61 #else
62 # undef  SUPPORT_CA_DIR
63 #endif
64 #if GNUTLS_VERSION_NUMBER >= 0x030014
65 # define SUPPORT_SYSDEFAULT_CABUNDLE
66 #endif
67 #if GNUTLS_VERSION_NUMBER >= 0x030104
68 # define GNUTLS_CERT_VFY_STATUS_PRINT
69 #endif
70 #if GNUTLS_VERSION_NUMBER >= 0x030109
71 # define SUPPORT_CORK
72 #endif
73 #if GNUTLS_VERSION_NUMBER >= 0x03010a
74 # define SUPPORT_GNUTLS_SESS_DESC
75 #endif
76 #if GNUTLS_VERSION_NUMBER >= 0x030300
77 # define GNUTLS_AUTO_GLOBAL_INIT
78 # define GNUTLS_AUTO_PKCS11_MANUAL
79 #endif
80 #if (GNUTLS_VERSION_NUMBER >= 0x030404) \
81   || (GNUTLS_VERSION_NUMBER >= 0x030311) && (GNUTLS_VERSION_NUMBER & 0xffff00 == 0x030300)
82 # ifndef DISABLE_OCSP
83 #  define EXIM_HAVE_OCSP
84 # endif
85 #endif
86 #if GNUTLS_VERSION_NUMBER >= 0x030500
87 # define SUPPORT_GNUTLS_KEYLOG
88 #endif
89 #if GNUTLS_VERSION_NUMBER >= 0x030506 && !defined(DISABLE_OCSP)
90 # define SUPPORT_SRV_OCSP_STACK
91 #endif
92 #if GNUTLS_VERSION_NUMBER >= 0x030603
93 # define EXIM_HAVE_TLS1_3
94 # define SUPPORT_GNUTLS_EXT_RAW_PARSE
95 # define GNUTLS_OCSP_STATUS_REQUEST_GET2
96 #endif
97
98 #ifdef SUPPORT_DANE
99 # if GNUTLS_VERSION_NUMBER >= 0x030000
100 #  define DANESSL_USAGE_DANE_TA 2
101 #  define DANESSL_USAGE_DANE_EE 3
102 # else
103 #  error GnuTLS version too early for DANE
104 # endif
105 # if GNUTLS_VERSION_NUMBER < 0x999999
106 #  define GNUTLS_BROKEN_DANE_VALIDATION
107 # endif
108 #endif
109
110 #ifndef DISABLE_TLS_RESUME
111 # if GNUTLS_VERSION_NUMBER >= 0x030603
112 #  define EXIM_HAVE_TLS_RESUME
113 # else
114 #  warning "GnuTLS library version too old; resumption unsupported"
115 # endif
116 #endif
117
118 #if GNUTLS_VERSION_NUMBER >= 0x030200
119 # ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
120 #  define EXIM_HAVE_ALPN
121 # endif
122 #endif
123
124 #ifndef DISABLE_OCSP
125 # include <gnutls/ocsp.h>
126 #endif
127 #ifdef SUPPORT_DANE
128 # include <gnutls/dane.h>
129 #endif
130
131 #include "tls-cipher-stdname.c"
132
133
134 #ifdef MACRO_PREDEF
135 void
136 options_tls(void)
137 {
138 # ifndef DISABLE_TLS_RESUME
139 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
140 # endif
141 # ifdef EXIM_HAVE_TLS1_3
142 builtin_macro_create(US"_HAVE_TLS1_3");
143 # endif
144 # ifdef EXIM_HAVE_OCSP
145 builtin_macro_create(US"_HAVE_TLS_OCSP");
146 # endif
147 # ifdef SUPPORT_SRV_OCSP_STACK
148 builtin_macro_create(US"_HAVE_TLS_OCSP_LIST");
149 # endif
150 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
151 builtin_macro_create(US"_HAVE_TLS_CA_CACHE");
152 # endif
153 # ifdef EXIM_HAVE_ALPN
154 builtin_macro_create(US"_HAVE_TLS_ALPN");
155 # endif
156 }
157 #else
158
159
160 /* GnuTLS 2 vs 3
161
162 GnuTLS 3 only:
163   gnutls_global_set_audit_log_function()
164
165 Changes:
166   gnutls_certificate_verify_peers2(): is new, drop the 2 for old version
167 */
168
169 /* Local static variables for GnuTLS */
170
171 /* Values for verify_requirement */
172
173 enum peer_verify_requirement
174   { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED, VERIFY_DANE };
175
176 /* This holds most state for server or client; with this, we can set up an
177 outbound TLS-enabled connection in an ACL callout, while not stomping all
178 over the TLS variables available for expansion.
179
180 Some of these correspond to variables in globals.c; those variables will
181 be set to point to content in one of these instances, as appropriate for
182 the stage of the process lifetime.
183
184 Not handled here: global tlsp->tls_channelbinding.
185 */
186
187 typedef struct exim_gnutls_state {
188   gnutls_session_t      session;
189
190   exim_tlslib_state     lib_state;
191 #define x509_cred               libdata0
192 #define pri_cache               libdata1
193
194   enum peer_verify_requirement verify_requirement;
195   int                   fd_in;
196   int                   fd_out;
197
198   BOOL                  peer_cert_verified:1;
199   BOOL                  peer_dane_verified:1;
200   BOOL                  trigger_sni_changes:1;
201   BOOL                  have_set_peerdn:1;
202   BOOL                  xfer_eof:1;     /*XXX never gets set! */
203   BOOL                  xfer_error:1;
204 #ifdef SUPPORT_CORK
205   BOOL                  corked:1;
206 #endif
207
208   const struct host_item *host;         /* NULL if server */
209   gnutls_x509_crt_t     peercert;
210   uschar                *peerdn;
211   uschar                *ciphersuite;
212   uschar                *received_sni;
213
214   const uschar *tls_certificate;
215   const uschar *tls_privatekey;
216   const uschar *tls_sni; /* client send only, not received */
217   const uschar *tls_verify_certificates;
218   const uschar *tls_crl;
219   const uschar *tls_require_ciphers;
220
221   uschar *exp_tls_certificate;
222   uschar *exp_tls_privatekey;
223   uschar *exp_tls_verify_certificates;
224   uschar *exp_tls_crl;
225   uschar *exp_tls_require_ciphers;
226   const uschar *exp_tls_verify_cert_hostnames;
227 #ifndef DISABLE_EVENT
228   uschar *event_action;
229 #endif
230 #ifdef SUPPORT_DANE
231   char * const *        dane_data;
232   const int *           dane_data_len;
233 #endif
234
235   tls_support *tlsp;    /* set in tls_init() */
236
237   uschar *xfer_buffer;
238   int xfer_buffer_lwm;
239   int xfer_buffer_hwm;
240 } exim_gnutls_state_st;
241
242 static const exim_gnutls_state_st exim_gnutls_state_init = {
243   /* all elements not explicitly intialised here get 0/NULL/FALSE */
244   .fd_in =              -1,
245   .fd_out =             -1,
246 };
247
248 /* Not only do we have our own APIs which don't pass around state, assuming
249 it's held in globals, GnuTLS doesn't appear to let us register callback data
250 for callbacks, or as part of the session, so we have to keep a "this is the
251 context we're currently dealing with" pointer and rely upon being
252 single-threaded to keep from processing data on an inbound TLS connection while
253 talking to another TLS connection for an outbound check.  This does mean that
254 there's no way for heart-beats to be responded to, for the duration of the
255 second connection.
256 XXX But see gnutls_session_get_ptr()
257 */
258
259 static exim_gnutls_state_st state_server = {
260   /* all elements not explicitly intialised here get 0/NULL/FALSE */
261   .fd_in =              -1,
262   .fd_out =             -1,
263 };
264
265 /* dh_params are initialised once within the lifetime of a process using TLS;
266 if we used TLS in a long-lived daemon, we'd have to reconsider this.  But we
267 don't want to repeat this. */
268
269 static gnutls_dh_params_t dh_server_params = NULL;
270
271 static int ssl_session_timeout = 7200;  /* Two hours */
272
273 static const uschar * const exim_default_gnutls_priority = US"NORMAL";
274
275 /* Guard library core initialisation */
276
277 static BOOL exim_gnutls_base_init_done = FALSE;
278
279 #ifndef DISABLE_OCSP
280 static BOOL gnutls_buggy_ocsp = FALSE;
281 static BOOL exim_testharness_disable_ocsp_validity_check = FALSE;
282 #endif
283
284 #ifdef EXIM_HAVE_ALPN
285 static int server_seen_alpn = -1;       /* count of names */
286 #endif
287 #ifdef EXIM_HAVE_TLS_RESUME
288 static gnutls_datum_t server_sessticket_key;
289 #endif
290
291
292 /* ------------------------------------------------------------------------ */
293 /* macros */
294
295 #define MAX_HOST_LEN 255
296
297 /* Set this to control gnutls_global_set_log_level(); values 0 to 9 will setup
298 the library logging; a value less than 0 disables the calls to set up logging
299 callbacks.  GNuTLS also looks for an environment variable - except not for
300 setuid binaries, making it useless - "GNUTLS_DEBUG_LEVEL".
301 Allegedly the testscript line "GNUTLS_DEBUG_LEVEL=9 sudo exim ..." would work,
302 but the env var must be added to /etc/sudoers too. */
303 #ifndef EXIM_GNUTLS_LIBRARY_LOG_LEVEL
304 # define EXIM_GNUTLS_LIBRARY_LOG_LEVEL -1
305 #endif
306
307 #ifndef EXIM_CLIENT_DH_MIN_BITS
308 # define EXIM_CLIENT_DH_MIN_BITS 1024
309 #endif
310
311 /* With GnuTLS 2.12.x+ we have gnutls_sec_param_to_pk_bits() with which we
312 can ask for a bit-strength.  Without that, we stick to the constant we had
313 before, for now. */
314 #ifndef EXIM_SERVER_DH_BITS_PRE2_12
315 # define EXIM_SERVER_DH_BITS_PRE2_12 1024
316 #endif
317
318 #define Expand_check_tlsvar(Varname, errstr) \
319   expand_check(state->Varname, US #Varname, &state->exp_##Varname, errstr)
320
321 #if GNUTLS_VERSION_NUMBER >= 0x020c00
322 # define HAVE_GNUTLS_SESSION_CHANNEL_BINDING
323 # define HAVE_GNUTLS_SEC_PARAM_CONSTANTS
324 # define HAVE_GNUTLS_RND
325 /* The security fix we provide with the gnutls_allow_auto_pkcs11 option
326  * (4.82 PP/09) introduces a compatibility regression. The symbol simply
327  * isn't available sometimes, so this needs to become a conditional
328  * compilation; the sanest way to deal with this being a problem on
329  * older OSes is to block it in the Local/Makefile with this compiler
330  * definition  */
331 # ifndef AVOID_GNUTLS_PKCS11
332 #  define HAVE_GNUTLS_PKCS11
333 # endif /* AVOID_GNUTLS_PKCS11 */
334 #endif
335
336
337
338
339 /* ------------------------------------------------------------------------ */
340 /* Callback declarations */
341
342 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
343 static void exim_gnutls_logger_cb(int level, const char *message);
344 #endif
345
346 static int exim_sni_handling_cb(gnutls_session_t session);
347
348 #ifdef EXIM_HAVE_TLS_RESUME
349 static int
350 tls_server_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
351   unsigned incoming, const gnutls_datum_t * msg);
352 #endif
353
354
355 /*************************************************
356 *               Handle TLS error                 *
357 *************************************************/
358
359 /* Called from lots of places when errors occur before actually starting to do
360 the TLS handshake, that is, while the session is still in clear. Always returns
361 DEFER for a server and FAIL for a client so that most calls can use "return
362 tls_error(...)" to do this processing and then give an appropriate return. A
363 single function is used for both server and client, because it is called from
364 some shared functions.
365
366 Argument:
367   prefix    text to include in the logged error
368   msg       additional error string (may be NULL)
369             usually obtained from gnutls_strerror()
370   host      NULL if setting up a server;
371             the connected host if setting up a client
372   errstr    pointer to returned error string
373
374 Returns:    OK/DEFER/FAIL
375 */
376
377 static int
378 tls_error(const uschar *prefix, const uschar *msg, const host_item *host,
379   uschar ** errstr)
380 {
381 if (errstr)
382   *errstr = string_sprintf("(%s)%s%s", prefix, msg ? ": " : "", msg ? msg : US"");
383 return host ? FAIL : DEFER;
384 }
385
386
387 static int
388 tls_error_gnu(exim_gnutls_state_st * state, const uschar *prefix, int err,
389   uschar ** errstr)
390 {
391 return tls_error(prefix,
392   state && err == GNUTLS_E_FATAL_ALERT_RECEIVED
393   ? US gnutls_alert_get_name(gnutls_alert_get(state->session))
394   : US gnutls_strerror(err),
395   state ? state->host : NULL,
396   errstr);
397 }
398
399 static int
400 tls_error_sys(const uschar *prefix, int err, const host_item *host,
401   uschar ** errstr)
402 {
403 return tls_error(prefix, US strerror(err), host, errstr);
404 }
405
406
407 /* ------------------------------------------------------------------------ */
408 /* Initialisation */
409
410 #ifndef DISABLE_OCSP
411
412 static BOOL
413 tls_is_buggy_ocsp(void)
414 {
415 const uschar * s;
416 uschar maj, mid, mic;
417
418 s = CUS gnutls_check_version(NULL);
419 maj = atoi(CCS s);
420 if (maj == 3)
421   {
422   while (*s && *s != '.') s++;
423   mid = atoi(CCS ++s);
424   if (mid <= 2)
425     return TRUE;
426   else if (mid >= 5)
427     return FALSE;
428   else
429     {
430     while (*s && *s != '.') s++;
431     mic = atoi(CCS ++s);
432     return mic <= (mid == 3 ? 16 : 3);
433     }
434   }
435 return FALSE;
436 }
437
438 #endif
439
440
441 static int
442 tls_g_init(uschar ** errstr)
443 {
444 int rc;
445 DEBUG(D_tls) debug_printf("GnuTLS global init required\n");
446
447 #if defined(HAVE_GNUTLS_PKCS11) && !defined(GNUTLS_AUTO_PKCS11_MANUAL)
448 /* By default, gnutls_global_init will init PKCS11 support in auto mode,
449 which loads modules from a config file, which sounds good and may be wanted
450 by some sysadmin, but also means in common configurations that GNOME keyring
451 environment variables are used and so breaks for users calling mailq.
452 To prevent this, we init PKCS11 first, which is the documented approach. */
453
454 if (!gnutls_allow_auto_pkcs11)
455   if ((rc = gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_MANUAL, NULL)))
456     return tls_error_gnu(NULL, US"gnutls_pkcs11_init", rc, errstr);
457 #endif
458
459 #ifndef GNUTLS_AUTO_GLOBAL_INIT
460 if ((rc = gnutls_global_init()))
461   return tls_error_gnu(NULL, US"gnutls_global_init", rc, errstr);
462 #endif
463
464 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
465 DEBUG(D_tls)
466   {
467   gnutls_global_set_log_function(exim_gnutls_logger_cb);
468   /* arbitrarily chosen level; bump up to 9 for more */
469   gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL);
470   }
471 #endif
472
473 #ifndef DISABLE_OCSP
474 if (tls_ocsp_file && (gnutls_buggy_ocsp = tls_is_buggy_ocsp()))
475   log_write(0, LOG_MAIN, "OCSP unusable with this GnuTLS library version");
476 #endif
477
478 exim_gnutls_base_init_done = TRUE;
479 return OK;
480 }
481
482
483
484 /* Daemon-call before each connection.  Nothing to do for GnuTLS. */
485
486 static void
487 tls_per_lib_daemon_tick(void)
488 {
489 }
490
491 /* Daemon one-time initialisation */
492
493 static void
494 tls_per_lib_daemon_init(void)
495 {
496 uschar * dummy_errstr;
497 static BOOL once = FALSE;
498
499 if (!exim_gnutls_base_init_done)
500   tls_g_init(&dummy_errstr);
501
502 if (!once)
503   {
504   once = TRUE;
505
506 #ifdef EXIM_HAVE_TLS_RESUME
507   /* We are dependent on the GnuTLS implementation of the Session Ticket
508   encryption; both the strength and the key rotation period.  We hope that
509   the strength at least matches that of the ciphersuite (but GnuTLS does not
510   document this). */
511
512   gnutls_session_ticket_key_generate(&server_sessticket_key);   /* >= 2.10.0 */
513   if (f.running_in_test_harness) ssl_session_timeout = 6;
514 #endif
515
516   tls_daemon_creds_reload();
517   }
518 }
519
520 /* ------------------------------------------------------------------------ */
521
522 /*************************************************
523 *    Deal with logging errors during I/O         *
524 *************************************************/
525
526 /* We have to get the identity of the peer from saved data.
527
528 Argument:
529   state    the current GnuTLS exim state container
530   rc       the GnuTLS error code, or 0 if it's a local error
531   when     text identifying read or write
532   text     local error text when rc is 0
533
534 Returns:   nothing
535 */
536
537 static void
538 record_io_error(exim_gnutls_state_st *state, int rc, uschar *when, uschar *text)
539 {
540 const uschar * msg;
541 uschar * errstr;
542
543 msg = rc == GNUTLS_E_FATAL_ALERT_RECEIVED
544   ? string_sprintf("A TLS fatal alert has been received: %s",
545       US gnutls_alert_get_name(gnutls_alert_get(state->session)))
546 #ifdef GNUTLS_E_PREMATURE_TERMINATION
547   : rc == GNUTLS_E_PREMATURE_TERMINATION && errno
548   ? string_sprintf("%s: syscall: %s", US gnutls_strerror(rc), strerror(errno))
549 #endif
550   : US gnutls_strerror(rc);
551
552 (void) tls_error(when, msg, state->host, &errstr);
553
554 if (state->host)
555   log_write(0, LOG_MAIN, "H=%s [%s] TLS error on connection %s",
556     state->host->name, state->host->address, errstr);
557 else
558   {
559   uschar * conn_info = smtp_get_connection_info();
560   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0) conn_info += 5;
561   /* I'd like to get separated H= here, but too hard for now */
562   log_write(0, LOG_MAIN, "TLS error on %s %s", conn_info, errstr);
563   }
564 }
565
566
567
568
569 /*************************************************
570 *        Set various Exim expansion vars         *
571 *************************************************/
572
573 #define exim_gnutls_cert_err(Label) \
574   do \
575     { \
576     if (rc != GNUTLS_E_SUCCESS) \
577       { \
578       DEBUG(D_tls) debug_printf("TLS: cert problem: %s: %s\n", \
579         (Label), gnutls_strerror(rc)); \
580       return rc; \
581       } \
582     } while (0)
583
584 static int
585 import_cert(const gnutls_datum_t * cert, gnutls_x509_crt_t * crtp)
586 {
587 int rc;
588
589 rc = gnutls_x509_crt_init(crtp);
590 exim_gnutls_cert_err(US"gnutls_x509_crt_init (crt)");
591
592 rc = gnutls_x509_crt_import(*crtp, cert, GNUTLS_X509_FMT_DER);
593 exim_gnutls_cert_err(US"failed to import certificate [gnutls_x509_crt_import(cert)]");
594
595 return rc;
596 }
597
598 #undef exim_gnutls_cert_err
599
600
601 /* We set various Exim global variables from the state, once a session has
602 been established.  With TLS callouts, may need to change this to stack
603 variables, or just re-call it with the server state after client callout
604 has finished.
605
606 Make sure anything set here is unset in tls_getc().
607
608 Sets:
609   tls_active                fd
610   tls_bits                  strength indicator
611   tls_certificate_verified  bool indicator
612   tls_channelbinding        for some SASL mechanisms
613   tls_ver                   a string
614   tls_cipher                a string
615   tls_peercert              pointer to library internal
616   tls_peerdn                a string
617   tls_sni                   a (UTF-8) string
618   tls_ourcert               pointer to library internal
619
620 Argument:
621   state      the relevant exim_gnutls_state_st *
622 */
623
624 static void
625 extract_exim_vars_from_tls_state(exim_gnutls_state_st * state)
626 {
627 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
628 int old_pool;
629 int rc;
630 gnutls_datum_t channel;
631 #endif
632 tls_support * tlsp = state->tlsp;
633
634 tlsp->active.sock = state->fd_out;
635 tlsp->active.tls_ctx = state;
636
637 DEBUG(D_tls) debug_printf("cipher: %s\n", state->ciphersuite);
638
639 tlsp->certificate_verified = state->peer_cert_verified;
640 #ifdef SUPPORT_DANE
641 tlsp->dane_verified = state->peer_dane_verified;
642 #endif
643
644 /* note that tls_channelbinding is not saved to the spool file, since it's
645 only available for use for authenticators while this TLS session is running. */
646
647 tlsp->channelbinding = NULL;
648 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
649 channel.data = NULL;
650 channel.size = 0;
651 if ((rc = gnutls_session_channel_binding(state->session, GNUTLS_CB_TLS_UNIQUE, &channel)))
652   { DEBUG(D_tls) debug_printf("Channel binding error: %s\n", gnutls_strerror(rc)); }
653 else
654   {
655   /* Declare the taintedness of the binding info.  On server, untainted; on
656   client, tainted - being the Finish msg from the server. */
657
658   old_pool = store_pool;
659   store_pool = POOL_PERM;
660   tlsp->channelbinding = b64encode_taint(CUS channel.data, (int)channel.size,
661                                           !!state->host);
662   store_pool = old_pool;
663   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage\n");
664   }
665 #endif
666
667 /* peercert is set in peer_status() */
668 tlsp->peerdn = state->peerdn;
669
670 /* do not corrupt sni sent by client; record sni rxd by server */
671 if (!state->host)
672   tlsp->sni = state->received_sni;
673
674 /* record our certificate */
675   {
676   const gnutls_datum_t * cert = gnutls_certificate_get_ours(state->session);
677   gnutls_x509_crt_t crt;
678
679   tlsp->ourcert = cert && import_cert(cert, &crt)==0 ? crt : NULL;
680   }
681 }
682
683
684
685
686 /*************************************************
687 *            Setup up DH parameters              *
688 *************************************************/
689
690 /* Generating the D-H parameters may take a long time. They only need to
691 be re-generated every so often, depending on security policy. What we do is to
692 keep these parameters in a file in the spool directory. If the file does not
693 exist, we generate them. This means that it is easy to cause a regeneration.
694
695 The new file is written as a temporary file and renamed, so that an incomplete
696 file is never present. If two processes both compute some new parameters, you
697 waste a bit of effort, but it doesn't seem worth messing around with locking to
698 prevent this.
699
700 Returns:     OK/DEFER/FAIL
701 */
702
703 static int
704 init_server_dh(uschar ** errstr)
705 {
706 int fd, rc;
707 unsigned int dh_bits;
708 gnutls_datum_t m;
709 uschar filename_buf[PATH_MAX];
710 uschar *filename = NULL;
711 size_t sz;
712 uschar *exp_tls_dhparam;
713 BOOL use_file_in_spool = FALSE;
714 host_item *host = NULL; /* dummy for macros */
715
716 DEBUG(D_tls) debug_printf("Initialising GnuTLS server params\n");
717
718 if ((rc = gnutls_dh_params_init(&dh_server_params)))
719   return tls_error_gnu(NULL, US"gnutls_dh_params_init", rc, errstr);
720
721 m.data = NULL;
722 m.size = 0;
723
724 if (!expand_check(tls_dhparam, US"tls_dhparam", &exp_tls_dhparam, errstr))
725   return DEFER;
726
727 if (!exp_tls_dhparam)
728   {
729   DEBUG(D_tls) debug_printf("Loading default hard-coded DH params\n");
730   m.data = US std_dh_prime_default();
731   m.size = Ustrlen(m.data);
732   }
733 else if (Ustrcmp(exp_tls_dhparam, "historic") == 0)
734   use_file_in_spool = TRUE;
735 else if (Ustrcmp(exp_tls_dhparam, "none") == 0)
736   {
737   DEBUG(D_tls) debug_printf("Requested no DH parameters\n");
738   return OK;
739   }
740 else if (exp_tls_dhparam[0] != '/')
741   {
742   if (!(m.data = US std_dh_prime_named(exp_tls_dhparam)))
743     return tls_error(US"No standard prime named", exp_tls_dhparam, NULL, errstr);
744   m.size = Ustrlen(m.data);
745   }
746 else
747   filename = exp_tls_dhparam;
748
749 if (m.data)
750   {
751   if ((rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM)))
752     return tls_error_gnu(NULL, US"gnutls_dh_params_import_pkcs3", rc, errstr);
753   DEBUG(D_tls) debug_printf("Loaded fixed standard D-H parameters\n");
754   return OK;
755   }
756
757 #ifdef HAVE_GNUTLS_SEC_PARAM_CONSTANTS
758 /* If you change this constant, also change dh_param_fn_ext so that we can use a
759 different filename and ensure we have sufficient bits. */
760
761 if (!(dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, GNUTLS_SEC_PARAM_NORMAL)))
762   return tls_error(US"gnutls_sec_param_to_pk_bits() failed", NULL, NULL, errstr);
763 DEBUG(D_tls)
764   debug_printf("GnuTLS tells us that for D-H PK, NORMAL is %d bits\n",
765       dh_bits);
766 #else
767 dh_bits = EXIM_SERVER_DH_BITS_PRE2_12;
768 DEBUG(D_tls)
769   debug_printf("GnuTLS lacks gnutls_sec_param_to_pk_bits(), using %d bits\n",
770       dh_bits);
771 #endif
772
773 /* Some clients have hard-coded limits. */
774 if (dh_bits > tls_dh_max_bits)
775   {
776   DEBUG(D_tls)
777     debug_printf("tls_dh_max_bits clamping override, using %d bits instead\n",
778         tls_dh_max_bits);
779   dh_bits = tls_dh_max_bits;
780   }
781
782 if (use_file_in_spool)
783   {
784   if (!string_format(filename_buf, sizeof(filename_buf),
785         "%s/gnutls-params-%d", spool_directory, dh_bits))
786     return tls_error(US"overlong filename", NULL, NULL, errstr);
787   filename = filename_buf;
788   }
789
790 /* Open the cache file for reading and if successful, read it and set up the
791 parameters. */
792
793 if ((fd = Uopen(filename, O_RDONLY, 0)) >= 0)
794   {
795   struct stat statbuf;
796   FILE *fp;
797   int saved_errno;
798
799   if (fstat(fd, &statbuf) < 0)  /* EIO */
800     {
801     saved_errno = errno;
802     (void)close(fd);
803     return tls_error_sys(US"TLS cache stat failed", saved_errno, NULL, errstr);
804     }
805   if (!S_ISREG(statbuf.st_mode))
806     {
807     (void)close(fd);
808     return tls_error(US"TLS cache not a file", NULL, NULL, errstr);
809     }
810   if (!(fp = fdopen(fd, "rb")))
811     {
812     saved_errno = errno;
813     (void)close(fd);
814     return tls_error_sys(US"fdopen(TLS cache stat fd) failed",
815         saved_errno, NULL, errstr);
816     }
817
818   m.size = statbuf.st_size;
819   if (!(m.data = store_malloc(m.size)))
820     {
821     fclose(fp);
822     return tls_error_sys(US"malloc failed", errno, NULL, errstr);
823     }
824   if (!(sz = fread(m.data, m.size, 1, fp)))
825     {
826     saved_errno = errno;
827     fclose(fp);
828     store_free(m.data);
829     return tls_error_sys(US"fread failed", saved_errno, NULL, errstr);
830     }
831   fclose(fp);
832
833   rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM);
834   store_free(m.data);
835   if (rc)
836     return tls_error_gnu(NULL, US"gnutls_dh_params_import_pkcs3", rc, errstr);
837   DEBUG(D_tls) debug_printf("read D-H parameters from file \"%s\"\n", filename);
838   }
839
840 /* If the file does not exist, fall through to compute new data and cache it.
841 If there was any other opening error, it is serious. */
842
843 else if (errno == ENOENT)
844   {
845   rc = -1;
846   DEBUG(D_tls)
847     debug_printf("D-H parameter cache file \"%s\" does not exist\n", filename);
848   }
849 else
850   return tls_error(string_open_failed("\"%s\" for reading", filename),
851       NULL, NULL, errstr);
852
853 /* If ret < 0, either the cache file does not exist, or the data it contains
854 is not useful. One particular case of this is when upgrading from an older
855 release of Exim in which the data was stored in a different format. We don't
856 try to be clever and support both formats; we just regenerate new data in this
857 case. */
858
859 if (rc < 0)
860   {
861   uschar *temp_fn;
862   unsigned int dh_bits_gen = dh_bits;
863
864   if ((PATH_MAX - Ustrlen(filename)) < 10)
865     return tls_error(US"Filename too long to generate replacement",
866         filename, NULL, errstr);
867
868   temp_fn = string_copy(US"exim-dh.XXXXXXX");
869   if ((fd = mkstemp(CS temp_fn)) < 0)   /* modifies temp_fn */
870     return tls_error_sys(US"Unable to open temp file", errno, NULL, errstr);
871   (void)exim_chown(temp_fn, exim_uid, exim_gid);   /* Probably not necessary */
872
873   /* GnuTLS overshoots!
874    * If we ask for 2236, we might get 2237 or more.
875    * But there's no way to ask GnuTLS how many bits there really are.
876    * We can ask how many bits were used in a TLS session, but that's it!
877    * The prime itself is hidden behind too much abstraction.
878    * So we ask for less, and proceed on a wing and a prayer.
879    * First attempt, subtracted 3 for 2233 and got 2240.
880    */
881   if (dh_bits >= EXIM_CLIENT_DH_MIN_BITS + 10)
882     {
883     dh_bits_gen = dh_bits - 10;
884     DEBUG(D_tls)
885       debug_printf("being paranoid about DH generation, make it '%d' bits'\n",
886           dh_bits_gen);
887     }
888
889   DEBUG(D_tls)
890     debug_printf("requesting generation of %d bit Diffie-Hellman prime ...\n",
891         dh_bits_gen);
892   if ((rc = gnutls_dh_params_generate2(dh_server_params, dh_bits_gen)))
893     return tls_error_gnu(NULL, US"gnutls_dh_params_generate2", rc, errstr);
894
895   /* gnutls_dh_params_export_pkcs3() will tell us the exact size, every time,
896   and I confirmed that a NULL call to get the size first is how the GnuTLS
897   sample apps handle this. */
898
899   sz = 0;
900   m.data = NULL;
901   if (  (rc = gnutls_dh_params_export_pkcs3(dh_server_params,
902                 GNUTLS_X509_FMT_PEM, m.data, &sz))
903      && rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
904     return tls_error_gnu(NULL, US"gnutls_dh_params_export_pkcs3(NULL) sizing",
905               rc, errstr);
906   m.size = sz;
907   if (!(m.data = store_malloc(m.size)))
908     return tls_error_sys(US"memory allocation failed", errno, NULL, errstr);
909
910   /* this will return a size 1 less than the allocation size above */
911   if ((rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
912       m.data, &sz)))
913     {
914     store_free(m.data);
915     return tls_error_gnu(NULL, US"gnutls_dh_params_export_pkcs3() real", rc, errstr);
916     }
917   m.size = sz; /* shrink by 1, probably */
918
919   if ((sz = write_to_fd_buf(fd, m.data, (size_t) m.size)) != m.size)
920     {
921     store_free(m.data);
922     return tls_error_sys(US"TLS cache write D-H params failed",
923         errno, NULL, errstr);
924     }
925   store_free(m.data);
926   if ((sz = write_to_fd_buf(fd, US"\n", 1)) != 1)
927     return tls_error_sys(US"TLS cache write D-H params final newline failed",
928         errno, NULL, errstr);
929
930   if ((rc = close(fd)))
931     return tls_error_sys(US"TLS cache write close() failed", errno, NULL, errstr);
932
933   if (Urename(temp_fn, filename) < 0)
934     return tls_error_sys(string_sprintf("failed to rename \"%s\" as \"%s\"",
935           temp_fn, filename), errno, NULL, errstr);
936
937   DEBUG(D_tls) debug_printf("wrote D-H parameters to file \"%s\"\n", filename);
938   }
939
940 DEBUG(D_tls) debug_printf("initialized server D-H parameters\n");
941 return OK;
942 }
943
944
945
946
947 /* Create and install a selfsigned certificate, for use in server mode. */
948
949 static int
950 tls_install_selfsign(exim_gnutls_state_st * state, uschar ** errstr)
951 {
952 gnutls_x509_crt_t cert = NULL;
953 time_t now;
954 gnutls_x509_privkey_t pkey = NULL;
955 const uschar * where;
956 int rc;
957
958 #ifndef SUPPORT_SELFSIGN
959 where = US"library too old";
960 rc = GNUTLS_E_NO_CERTIFICATE_FOUND;
961 if (TRUE) goto err;
962 #endif
963
964 DEBUG(D_tls) debug_printf("TLS: generating selfsigned server cert\n");
965 where = US"initialising pkey";
966 if ((rc = gnutls_x509_privkey_init(&pkey))) goto err;
967
968 where = US"initialising cert";
969 if ((rc = gnutls_x509_crt_init(&cert))) goto err;
970
971 where = US"generating pkey";    /* Hangs on 2.12.23 */
972 if ((rc = gnutls_x509_privkey_generate(pkey, GNUTLS_PK_RSA,
973 #ifdef SUPPORT_PARAM_TO_PK_BITS
974 # ifndef GNUTLS_SEC_PARAM_MEDIUM
975 #  define GNUTLS_SEC_PARAM_MEDIUM GNUTLS_SEC_PARAM_HIGH
976 # endif
977             gnutls_sec_param_to_pk_bits(GNUTLS_PK_RSA, GNUTLS_SEC_PARAM_MEDIUM),
978 #else
979             2048,
980 #endif
981             0)))
982   goto err;
983
984 where = US"configuring cert";
985 now = 1;
986 if (  (rc = gnutls_x509_crt_set_version(cert, 3))
987    || (rc = gnutls_x509_crt_set_serial(cert, &now, sizeof(now)))
988    || (rc = gnutls_x509_crt_set_activation_time(cert, now = time(NULL)))
989    || (rc = gnutls_x509_crt_set_expiration_time(cert, (long)2 * 60 * 60))       /* 2 hour */
990    || (rc = gnutls_x509_crt_set_key(cert, pkey))
991
992    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
993               GNUTLS_OID_X520_COUNTRY_NAME, 0, "UK", 2))
994    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
995               GNUTLS_OID_X520_ORGANIZATION_NAME, 0, "Exim Developers", 15))
996    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
997               GNUTLS_OID_X520_COMMON_NAME, 0,
998               smtp_active_hostname, Ustrlen(smtp_active_hostname)))
999    )
1000   goto err;
1001
1002 where = US"signing cert";
1003 if ((rc = gnutls_x509_crt_sign(cert, cert, pkey))) goto err;
1004
1005 where = US"installing selfsign cert";
1006                                         /* Since: 2.4.0 */
1007 if ((rc = gnutls_certificate_set_x509_key(state->lib_state.x509_cred,
1008     &cert, 1, pkey)))
1009   goto err;
1010
1011 rc = OK;
1012
1013 out:
1014   if (cert) gnutls_x509_crt_deinit(cert);
1015   if (pkey) gnutls_x509_privkey_deinit(pkey);
1016   return rc;
1017
1018 err:
1019   rc = tls_error_gnu(state, where, rc, errstr);
1020   goto out;
1021 }
1022
1023
1024
1025
1026 /* Add certificate and key, from files.
1027
1028 Return:
1029   Zero or negative: good.  Negate value for certificate index if < 0.
1030   Greater than zero: FAIL or DEFER code.
1031 */
1032
1033 static int
1034 tls_add_certfile(exim_gnutls_state_st * state, const host_item * host,
1035   const uschar * certfile, const uschar * keyfile, uschar ** errstr)
1036 {
1037 int rc = gnutls_certificate_set_x509_key_file(state->lib_state.x509_cred,
1038     CCS certfile, CCS keyfile, GNUTLS_X509_FMT_PEM);
1039 if (rc < 0)
1040   return tls_error_gnu(state,
1041     string_sprintf("cert/key setup: cert=%s key=%s", certfile, keyfile),
1042     rc, errstr);
1043 return -rc;
1044 }
1045
1046
1047 #if !defined(DISABLE_OCSP) && !defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
1048 /* Load an OCSP proof from file for sending by the server.  Called
1049 on getting a status-request handshake message, for earlier versions
1050 of GnuTLS. */
1051
1052 static int
1053 server_ocsp_stapling_cb(gnutls_session_t session, void * ptr,
1054   gnutls_datum_t * ocsp_response)
1055 {
1056 int ret;
1057 DEBUG(D_tls) debug_printf("OCSP stapling callback: %s\n", US ptr);
1058
1059 if ((ret = gnutls_load_file(ptr, ocsp_response)) < 0)
1060   {
1061   DEBUG(D_tls) debug_printf("Failed to load ocsp stapling file %s\n",
1062                               CS ptr);
1063   tls_in.ocsp = OCSP_NOT_RESP;
1064   return GNUTLS_E_NO_CERTIFICATE_STATUS;
1065   }
1066
1067 tls_in.ocsp = OCSP_VFY_NOT_TRIED;
1068 return 0;
1069 }
1070 #endif
1071
1072
1073 #ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
1074 /* Make a note that we saw a status-request */
1075 static int
1076 tls_server_clienthello_ext(void * ctx, unsigned tls_id,
1077   const uschar * data, unsigned size)
1078 {
1079 /* The values for tls_id are documented here:
1080 https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml */
1081 switch (tls_id)
1082   {
1083   case 5:       /* Status Request */
1084     DEBUG(D_tls) debug_printf("Seen status_request extension from client\n");
1085     tls_in.ocsp = OCSP_NOT_RESP;
1086     break;
1087 #ifdef EXIM_HAVE_ALPN
1088   case 16:      /* Application Layer Protocol Notification */
1089     /* The format of "data" here doesn't seem to be documented, but appears
1090     to be a 2-byte field with a (redundant, given the "size" arg) total length
1091     then a sequence of one-byte size then string (not nul-term) names.  The
1092     latter is as described in OpenSSL documentation. */
1093
1094     DEBUG(D_tls) debug_printf("Seen ALPN extension from client (s=%u):", size);
1095     for (const uschar * s = data+2; s-data < size-1; s += *s + 1)
1096       {
1097       server_seen_alpn++;
1098       DEBUG(D_tls) debug_printf(" '%.*s'", (int)*s, s+1);
1099       }
1100     DEBUG(D_tls) debug_printf("\n");
1101     if (server_seen_alpn > 1)
1102       {
1103       DEBUG(D_tls) debug_printf("TLS: too many ALPNs presented in handshake\n");
1104       return GNUTLS_E_NO_APPLICATION_PROTOCOL;
1105       }
1106     break;
1107 #endif
1108   }
1109 return 0;
1110 }
1111
1112 /* Callback for client-hello, on server, if we think we might serve stapled-OCSP */
1113 static int
1114 tls_server_clienthello_cb(gnutls_session_t session, unsigned int htype,
1115   unsigned when, unsigned int incoming, const gnutls_datum_t * msg)
1116 {
1117 /* Call fn for each extension seen.  3.6.3 onwards */
1118 return gnutls_ext_raw_parse(NULL, tls_server_clienthello_ext, msg,
1119                            GNUTLS_EXT_RAW_FLAG_TLS_CLIENT_HELLO);
1120 }
1121
1122
1123 # ifdef notdef_crashes
1124 /* Make a note that we saw a status-response */
1125 static int
1126 tls_server_servercerts_ext(void * ctx, unsigned tls_id,
1127   const unsigned char *data, unsigned size)
1128 {
1129 /* debug_printf("%s %u\n", __FUNCTION__, tls_id); */
1130 /* https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml */
1131 if (FALSE && tls_id == 5)       /* status_request */
1132   {
1133   DEBUG(D_tls) debug_printf("Seen status_request extension\n");
1134   tls_in.ocsp = exim_testharness_disable_ocsp_validity_check
1135     ? OCSP_VFY_NOT_TRIED : OCSP_VFIED;  /* We know that GnuTLS verifies responses */
1136   }
1137 return 0;
1138 }
1139 # endif
1140
1141 /* Callback for certificates packet, on server, if we think we might serve stapled-OCSP */
1142 static int
1143 tls_server_servercerts_cb(gnutls_session_t session, unsigned int htype,
1144   unsigned when, unsigned int incoming, const gnutls_datum_t * msg)
1145 {
1146 /* Call fn for each extension seen.  3.6.3 onwards */
1147 # ifdef notdef_crashes
1148                                 /*XXX crashes */
1149 return gnutls_ext_raw_parse(NULL, tls_server_servercerts_ext, msg, 0);
1150 # endif
1151 }
1152 #endif /*SUPPORT_GNUTLS_EXT_RAW_PARSE*/
1153
1154 /*XXX in tls1.3 the cert-status travel as an extension next to the cert, in the
1155  "Handshake Protocol: Certificate" record.
1156 So we need to spot the Certificate handshake message, parse it and spot any status_request extension(s)
1157
1158 This is different to tls1.2 - where it is a separate record (wireshark term) / handshake message (gnutls term).
1159 */
1160
1161 #if defined(EXIM_HAVE_TLS_RESUME) || defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
1162 /* Callback for certificate-status, on server. We sent stapled OCSP. */
1163 static int
1164 tls_server_certstatus_cb(gnutls_session_t session, unsigned int htype,
1165   unsigned when, unsigned int incoming, const gnutls_datum_t * msg)
1166 {
1167 DEBUG(D_tls) debug_printf("Sending certificate-status\n");              /*XXX we get this for tls1.2 but not for 1.3 */
1168 # ifdef SUPPORT_SRV_OCSP_STACK
1169 tls_in.ocsp = exim_testharness_disable_ocsp_validity_check
1170   ? OCSP_VFY_NOT_TRIED : OCSP_VFIED;    /* We know that GnuTLS verifies responses */
1171 # else
1172 tls_in.ocsp = OCSP_VFY_NOT_TRIED;
1173 # endif
1174 return 0;
1175 }
1176
1177 /* Callback for handshake messages, on server */
1178 static int
1179 tls_server_hook_cb(gnutls_session_t sess, u_int htype, unsigned when,
1180   unsigned incoming, const gnutls_datum_t * msg)
1181 {
1182 /* debug_printf("%s: htype %u\n", __FUNCTION__, htype); */
1183 switch (htype)
1184   {
1185 # ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
1186   case GNUTLS_HANDSHAKE_CLIENT_HELLO:
1187     return tls_server_clienthello_cb(sess, htype, when, incoming, msg);
1188   case GNUTLS_HANDSHAKE_CERTIFICATE_PKT:
1189     return tls_server_servercerts_cb(sess, htype, when, incoming, msg);
1190 # endif
1191   case GNUTLS_HANDSHAKE_CERTIFICATE_STATUS:
1192     return tls_server_certstatus_cb(sess, htype, when, incoming, msg);
1193 # ifdef EXIM_HAVE_TLS_RESUME
1194   case GNUTLS_HANDSHAKE_NEW_SESSION_TICKET:
1195     return tls_server_ticket_cb(sess, htype, when, incoming, msg);
1196 # endif
1197   default:
1198     return 0;
1199   }
1200 }
1201 #endif
1202
1203
1204 #if !defined(DISABLE_OCSP) && defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
1205 static void
1206 tls_server_testharness_ocsp_fiddle(void)
1207 {
1208 extern char ** environ;
1209 if (environ) for (uschar ** p = USS environ; *p; p++)
1210   if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1211     {
1212     DEBUG(D_tls) debug_printf("Permitting known bad OCSP response\n");
1213     exim_testharness_disable_ocsp_validity_check = TRUE;
1214     }
1215 }
1216 #endif
1217
1218 /**************************************************
1219 * One-time init credentials for server and client *
1220 **************************************************/
1221
1222 static void
1223 creds_basic_init(gnutls_certificate_credentials_t x509_cred, BOOL server)
1224 {
1225 #ifdef SUPPORT_SRV_OCSP_STACK
1226 gnutls_certificate_set_flags(x509_cred, GNUTLS_CERTIFICATE_API_V2);
1227
1228 # if !defined(DISABLE_OCSP) && defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
1229 if (server && tls_ocsp_file)
1230   {
1231   if (f.running_in_test_harness)
1232     tls_server_testharness_ocsp_fiddle();
1233
1234   if (exim_testharness_disable_ocsp_validity_check)
1235     gnutls_certificate_set_flags(x509_cred,
1236       GNUTLS_CERTIFICATE_API_V2 | GNUTLS_CERTIFICATE_SKIP_OCSP_RESPONSE_CHECK);
1237   }
1238 # endif
1239 #endif
1240 DEBUG(D_tls)
1241   debug_printf("TLS: basic cred init, %s\n", server ? "server" : "client");
1242 }
1243
1244 static int
1245 creds_load_server_certs(exim_gnutls_state_st * state, const uschar * cert,
1246   const uschar * pkey, const uschar * ocsp, uschar ** errstr)
1247 {
1248 const uschar * clist = cert;
1249 const uschar * klist = pkey;
1250 const uschar * olist;
1251 int csep = 0, ksep = 0, osep = 0, cnt = 0, rc;
1252 uschar * cfile, * kfile, * ofile;
1253 #ifndef DISABLE_OCSP
1254 # ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
1255 gnutls_x509_crt_fmt_t ocsp_fmt = GNUTLS_X509_FMT_DER;
1256 # endif
1257
1258 if (!expand_check(ocsp, US"tls_ocsp_file", &ofile, errstr))
1259   return DEFER;
1260 olist = ofile;
1261 #endif
1262
1263 while (cfile = string_nextinlist(&clist, &csep, NULL, 0))
1264
1265   if (!(kfile = string_nextinlist(&klist, &ksep, NULL, 0)))
1266     return tls_error(US"cert/key setup: out of keys", NULL, NULL, errstr);
1267   else if ((rc = tls_add_certfile(state, NULL, cfile, kfile, errstr)) > 0)
1268     return rc;
1269   else
1270     {
1271     int gnutls_cert_index = -rc;
1272     DEBUG(D_tls) debug_printf("TLS: cert/key %d %s registered\n",
1273                               gnutls_cert_index, cfile);
1274
1275 #ifndef DISABLE_OCSP
1276     if (ocsp)
1277       {
1278       /* Set the OCSP stapling server info */
1279       if (gnutls_buggy_ocsp)
1280         {
1281         DEBUG(D_tls)
1282           debug_printf("GnuTLS library is buggy for OCSP; avoiding\n");
1283         }
1284       else if ((ofile = string_nextinlist(&olist, &osep, NULL, 0)))
1285         {
1286         DEBUG(D_tls) debug_printf("OCSP response file %d  = %s\n",
1287                                   gnutls_cert_index, ofile);
1288 # ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
1289         if (Ustrncmp(ofile, US"PEM ", 4) == 0)
1290           {
1291           ocsp_fmt = GNUTLS_X509_FMT_PEM;
1292           ofile += 4;
1293           }
1294         else if (Ustrncmp(ofile, US"DER ", 4) == 0)
1295           {
1296           ocsp_fmt = GNUTLS_X509_FMT_DER;
1297           ofile += 4;
1298           }
1299
1300         if  ((rc = gnutls_certificate_set_ocsp_status_request_file2(
1301                   state->lib_state.x509_cred, CCS ofile, gnutls_cert_index,
1302                   ocsp_fmt)) < 0)
1303           return tls_error_gnu(state,
1304                   US"gnutls_certificate_set_ocsp_status_request_file2",
1305                   rc, errstr);
1306         DEBUG(D_tls)
1307           debug_printf(" %d response%s loaded\n", rc, rc>1 ? "s":"");
1308
1309         /* Arrange callbacks for OCSP request observability */
1310
1311         if (state->session)
1312           gnutls_handshake_set_hook_function(state->session,
1313             GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST, tls_server_hook_cb);
1314         else
1315           state->lib_state.ocsp_hook = TRUE;
1316
1317
1318 # else
1319 #  if defined(SUPPORT_SRV_OCSP_STACK)
1320         if ((rc = gnutls_certificate_set_ocsp_status_request_function2(
1321                      state->lib_state.x509_cred, gnutls_cert_index,
1322                      server_ocsp_stapling_cb, ofile)))
1323             return tls_error_gnu(state,
1324                   US"gnutls_certificate_set_ocsp_status_request_function2",
1325                   rc, errstr);
1326         else
1327 #  endif
1328           {
1329           if (cnt++ > 0)
1330             {
1331             DEBUG(D_tls)
1332               debug_printf("oops; multiple OCSP files not supported\n");
1333             break;
1334             }
1335           gnutls_certificate_set_ocsp_status_request_function(
1336             state->lib_state.x509_cred, server_ocsp_stapling_cb, ofile);
1337           }
1338 # endif /* SUPPORT_GNUTLS_EXT_RAW_PARSE */
1339         }
1340       else
1341         DEBUG(D_tls) debug_printf("ran out of OCSP response files in list\n");
1342       }
1343 #endif /* DISABLE_OCSP */
1344     }
1345 return 0;
1346 }
1347
1348 static int
1349 creds_load_client_certs(exim_gnutls_state_st * state, const host_item * host,
1350   const uschar * cert, const uschar * pkey, uschar ** errstr)
1351 {
1352 int rc = tls_add_certfile(state, host, cert, pkey, errstr);
1353 if (rc > 0) return rc;
1354 DEBUG(D_tls) debug_printf("TLS: cert/key registered\n");
1355 return 0;
1356 }
1357
1358 static int
1359 creds_load_cabundle(exim_gnutls_state_st * state, const uschar * bundle,
1360   const host_item * host, uschar ** errstr)
1361 {
1362 int cert_count;
1363 struct stat statbuf;
1364
1365 #ifdef SUPPORT_SYSDEFAULT_CABUNDLE
1366 if (Ustrcmp(bundle, "system") == 0 || Ustrncmp(bundle, "system,", 7) == 0)
1367   cert_count = gnutls_certificate_set_x509_system_trust(state->lib_state.x509_cred);
1368 else
1369 #endif
1370   {
1371   if (Ustat(bundle, &statbuf) < 0)
1372     {
1373     log_write(0, LOG_MAIN|LOG_PANIC, "could not stat '%s' "
1374         "(tls_verify_certificates): %s", bundle, strerror(errno));
1375     return DEFER;
1376     }
1377
1378 #ifndef SUPPORT_CA_DIR
1379   /* The test suite passes in /dev/null; we could check for that path explicitly,
1380   but who knows if someone has some weird FIFO which always dumps some certs, or
1381   other weirdness.  The thing we really want to check is that it's not a
1382   directory, since while OpenSSL supports that, GnuTLS does not.
1383   So s/!S_ISREG/S_ISDIR/ and change some messaging ... */
1384   if (S_ISDIR(statbuf.st_mode))
1385     {
1386     log_write(0, LOG_MAIN|LOG_PANIC,
1387         "tls_verify_certificates \"%s\" is a directory", bundle);
1388     return DEFER;
1389     }
1390 #endif
1391
1392   DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
1393           bundle, statbuf.st_size);
1394
1395   if (statbuf.st_size == 0)
1396     {
1397     DEBUG(D_tls)
1398       debug_printf("cert file empty, no certs, no verification, ignoring any CRL\n");
1399     return OK;
1400     }
1401
1402   cert_count =
1403
1404 #ifdef SUPPORT_CA_DIR
1405     (statbuf.st_mode & S_IFMT) == S_IFDIR
1406     ?
1407     gnutls_certificate_set_x509_trust_dir(state->lib_state.x509_cred,
1408       CS bundle, GNUTLS_X509_FMT_PEM)
1409     :
1410 #endif
1411     gnutls_certificate_set_x509_trust_file(state->lib_state.x509_cred,
1412       CS bundle, GNUTLS_X509_FMT_PEM);
1413
1414 #ifdef SUPPORT_CA_DIR
1415   /* Mimic the behaviour with OpenSSL of not advertising a usable-cert list
1416   when using the directory-of-certs config model. */
1417
1418   if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1419     if (state->session)
1420       gnutls_certificate_send_x509_rdn_sequence(state->session, 1);
1421     else
1422       state->lib_state.ca_rdn_emulate = TRUE;
1423 #endif
1424   }
1425
1426 if (cert_count < 0)
1427   return tls_error_gnu(state, US"setting certificate trust", cert_count, errstr);
1428 DEBUG(D_tls)
1429   debug_printf("Added %d certificate authorities\n", cert_count);
1430
1431 return OK;
1432 }
1433
1434
1435 static int
1436 creds_load_crl(exim_gnutls_state_st * state, const uschar * crl, uschar ** errstr)
1437 {
1438 int cert_count;
1439 DEBUG(D_tls) debug_printf("loading CRL file = %s\n", crl);
1440 if ((cert_count = gnutls_certificate_set_x509_crl_file(state->lib_state.x509_cred,
1441     CS crl, GNUTLS_X509_FMT_PEM)) < 0)
1442   return tls_error_gnu(state, US"gnutls_certificate_set_x509_crl_file",
1443             cert_count, errstr);
1444
1445 DEBUG(D_tls) debug_printf("Processed %d CRLs\n", cert_count);
1446 return OK;
1447 }
1448
1449
1450 static int
1451 creds_load_pristring(exim_gnutls_state_st * state, const uschar * p,
1452   const char ** errpos)
1453 {
1454 if (!p)
1455   {
1456   p = exim_default_gnutls_priority;
1457   DEBUG(D_tls)
1458     debug_printf("GnuTLS using default session cipher/priority \"%s\"\n", p);
1459   }
1460 return gnutls_priority_init( (gnutls_priority_t *) &state->lib_state.pri_cache,
1461   CCS p, errpos);
1462 }
1463
1464 static unsigned
1465 tls_server_creds_init(void)
1466 {
1467 uschar * dummy_errstr;
1468 unsigned lifetime = 0;
1469
1470 state_server.lib_state = null_tls_preload;
1471 if (gnutls_certificate_allocate_credentials(
1472       (gnutls_certificate_credentials_t *) &state_server.lib_state.x509_cred))
1473   {
1474   state_server.lib_state.x509_cred = NULL;
1475   return lifetime;
1476   }
1477 creds_basic_init(state_server.lib_state.x509_cred, TRUE);
1478
1479 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1480 /* If tls_certificate has any $ indicating expansions, it is not good.
1481 If tls_privatekey is set but has $, not good.  Likewise for tls_ocsp_file.
1482 If all good (and tls_certificate set), load the cert(s). */
1483
1484 if (  opt_set_and_noexpand(tls_certificate)
1485 # ifndef DISABLE_OCSP
1486    && opt_unset_or_noexpand(tls_ocsp_file)
1487 # endif
1488    && opt_unset_or_noexpand(tls_privatekey))
1489   {
1490   /* Set watches on the filenames.  The implementation does de-duplication
1491   so we can just blindly do them all.
1492   */
1493
1494   if (  tls_set_watch(tls_certificate, TRUE)
1495 # ifndef DISABLE_OCSP
1496      && tls_set_watch(tls_ocsp_file, TRUE)
1497 # endif
1498      && tls_set_watch(tls_privatekey, TRUE))
1499     {
1500     DEBUG(D_tls) debug_printf("TLS: preloading server certs\n");
1501     if (creds_load_server_certs(&state_server, tls_certificate,
1502           tls_privatekey && *tls_privatekey ? tls_privatekey : tls_certificate,
1503 # ifdef DISABLE_OCSP
1504           NULL,
1505 # else
1506           tls_ocsp_file,
1507 # endif
1508           &dummy_errstr) == 0)
1509       state_server.lib_state.conn_certs = TRUE;
1510     }
1511   }
1512 else if (  !tls_certificate && !tls_privatekey
1513 # ifndef DISABLE_OCSP
1514         && !tls_ocsp_file
1515 # endif
1516         )
1517   {             /* Generate & preload a selfsigned cert. No files to watch. */
1518   if ((tls_install_selfsign(&state_server, &dummy_errstr)) == OK)
1519     {
1520     state_server.lib_state.conn_certs = TRUE;
1521     lifetime = f.running_in_test_harness ? 2 : 60 * 60;         /* 1 hour */
1522     }
1523   }
1524 else
1525   DEBUG(D_tls) debug_printf("TLS: not preloading server certs\n");
1526
1527 /* If tls_verify_certificates is non-empty and has no $, load CAs.
1528 If none was configured and we can't handle "system", treat as empty. */
1529
1530 if (  opt_set_and_noexpand(tls_verify_certificates)
1531 #ifndef SUPPORT_SYSDEFAULT_CABUNDLE
1532    && Ustrcmp(tls_verify_certificates, "system") != 0
1533 #endif
1534    )
1535   {
1536   if (tls_set_watch(tls_verify_certificates, FALSE))
1537     {
1538     DEBUG(D_tls) debug_printf("TLS: preloading CA bundle for server\n");
1539     if (creds_load_cabundle(&state_server, tls_verify_certificates,
1540                             NULL, &dummy_errstr) != OK)
1541       return lifetime;
1542     state_server.lib_state.cabundle = TRUE;
1543
1544     /* If CAs loaded and tls_crl is non-empty and has no $, load it */
1545
1546     if (opt_set_and_noexpand(tls_crl))
1547       {
1548       if (tls_set_watch(tls_crl, FALSE))
1549         {
1550         DEBUG(D_tls) debug_printf("TLS: preloading CRL for server\n");
1551         if (creds_load_crl(&state_server, tls_crl, &dummy_errstr) != OK)
1552           return lifetime;
1553         state_server.lib_state.crl = TRUE;
1554         }
1555       }
1556     else
1557       DEBUG(D_tls) debug_printf("TLS: not preloading CRL for server\n");
1558     }
1559   }
1560 else
1561   DEBUG(D_tls) debug_printf("TLS: not preloading CA bundle for server\n");
1562 #endif  /* EXIM_HAVE_INOTIFY */
1563
1564 /* If tls_require_ciphers is non-empty and has no $, load the
1565 ciphers priority cache.  If unset, load with the default.
1566 (server-only as the client one depends on non/DANE) */
1567
1568 if (!tls_require_ciphers || opt_set_and_noexpand(tls_require_ciphers))
1569   {
1570   const char * dummy_errpos;
1571   DEBUG(D_tls) debug_printf("TLS: preloading cipher list for server: %s\n",
1572                   tls_require_ciphers);
1573   if (  creds_load_pristring(&state_server, tls_require_ciphers, &dummy_errpos)
1574      == OK)
1575     state_server.lib_state.pri_string = TRUE;
1576   }
1577 else
1578   DEBUG(D_tls) debug_printf("TLS: not preloading cipher list for server\n");
1579 return lifetime;
1580 }
1581
1582
1583 /* Preload whatever creds are static, onto a transport.  The client can then
1584 just copy the pointer as it starts up. */
1585
1586 static void
1587 tls_client_creds_init(transport_instance * t, BOOL watch)
1588 {
1589 smtp_transport_options_block * ob = t->options_block;
1590 exim_gnutls_state_st tpt_dummy_state;
1591 host_item * dummy_host = (host_item *)1;
1592 uschar * dummy_errstr;
1593
1594 if (  !exim_gnutls_base_init_done
1595    && tls_g_init(&dummy_errstr) != OK)
1596   return;
1597
1598 ob->tls_preload = null_tls_preload;
1599 if (gnutls_certificate_allocate_credentials(
1600   (struct gnutls_certificate_credentials_st **)&ob->tls_preload.x509_cred))
1601   {
1602   ob->tls_preload.x509_cred = NULL;
1603   return;
1604   }
1605 creds_basic_init(ob->tls_preload.x509_cred, FALSE);
1606
1607 tpt_dummy_state.session = NULL;
1608 tpt_dummy_state.lib_state = ob->tls_preload;
1609
1610 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1611 if (  opt_set_and_noexpand(ob->tls_certificate)
1612    && opt_unset_or_noexpand(ob->tls_privatekey))
1613   {
1614   if (  !watch
1615      || (  tls_set_watch(ob->tls_certificate, FALSE)
1616         && tls_set_watch(ob->tls_privatekey, FALSE)
1617      )  )
1618     {
1619     const uschar * pkey = ob->tls_privatekey;
1620
1621     DEBUG(D_tls)
1622       debug_printf("TLS: preloading client certs for transport '%s'\n", t->name);
1623
1624     /* The state->lib_state.x509_cred is used for the certs load, and is the sole
1625     structure element used.  So we can set up a dummy.  The hoat arg only
1626     selects a retcode in case of fail, so any value */
1627
1628     if (creds_load_client_certs(&tpt_dummy_state, dummy_host,
1629           ob->tls_certificate, pkey ? pkey : ob->tls_certificate,
1630           &dummy_errstr) == OK)
1631       ob->tls_preload.conn_certs = TRUE;
1632     }
1633   }
1634 else
1635   DEBUG(D_tls)
1636     debug_printf("TLS: not preloading client certs, for transport '%s'\n", t->name);
1637
1638 /* If tls_verify_certificates is non-empty and has no $, load CAs.
1639 If none was configured and we can't handle "system", treat as empty. */
1640
1641 if (  opt_set_and_noexpand(ob->tls_verify_certificates)
1642 #ifndef SUPPORT_SYSDEFAULT_CABUNDLE
1643    && Ustrcmp(ob->tls_verify_certificates, "system") != 0
1644 #endif
1645    )
1646   {
1647   if (!watch || tls_set_watch(ob->tls_verify_certificates, FALSE))
1648     {
1649     DEBUG(D_tls)
1650       debug_printf("TLS: preloading CA bundle for transport '%s'\n", t->name);
1651     if (creds_load_cabundle(&tpt_dummy_state, ob->tls_verify_certificates,
1652                             dummy_host, &dummy_errstr) != OK)
1653       return;
1654     ob->tls_preload.cabundle = TRUE;
1655
1656     if (opt_set_and_noexpand(ob->tls_crl))
1657       {
1658       if (!watch || tls_set_watch(ob->tls_crl, FALSE))
1659         {
1660         DEBUG(D_tls) debug_printf("TLS: preloading CRL for transport '%s'\n", t->name);
1661         if (creds_load_crl(&tpt_dummy_state, ob->tls_crl, &dummy_errstr) != OK)
1662           return;
1663         ob->tls_preload.crl = TRUE;
1664         }
1665       }
1666     else
1667       DEBUG(D_tls) debug_printf("TLS: not preloading CRL, for transport '%s'\n", t->name);
1668     }
1669   }
1670 else
1671   DEBUG(D_tls)
1672       debug_printf("TLS: not preloading CA bundle, for transport '%s'\n", t->name);
1673
1674 /* We do not preload tls_require_ciphers to to the transport as it implicitly
1675 depends on DANE or plain usage. */
1676
1677 #endif
1678 }
1679
1680
1681 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1682 /* Invalidate the creds cached, by dropping the current ones.
1683 Call when we notice one of the source files has changed. */
1684  
1685 static void
1686 tls_server_creds_invalidate(void)
1687 {
1688 if (state_server.lib_state.pri_cache)
1689   gnutls_priority_deinit(state_server.lib_state.pri_cache);
1690 state_server.lib_state.pri_cache = NULL;
1691
1692 if (state_server.lib_state.x509_cred)
1693   gnutls_certificate_free_credentials(state_server.lib_state.x509_cred);
1694 state_server.lib_state = null_tls_preload;
1695 }
1696
1697
1698 static void
1699 tls_client_creds_invalidate(transport_instance * t)
1700 {
1701 smtp_transport_options_block * ob = t->options_block;
1702 if (ob->tls_preload.x509_cred)
1703   gnutls_certificate_free_credentials(ob->tls_preload.x509_cred);
1704 ob->tls_preload = null_tls_preload;
1705 }
1706 #endif
1707
1708
1709 /*************************************************
1710 *       Variables re-expanded post-SNI           *
1711 *************************************************/
1712
1713 /* Called from both server and client code, via tls_init(), and also from
1714 the SNI callback after receiving an SNI, if tls_certificate includes "tls_sni".
1715
1716 We can tell the two apart by state->received_sni being non-NULL in callback.
1717
1718 The callback should not call us unless state->trigger_sni_changes is true,
1719 which we are responsible for setting on the first pass through.
1720
1721 Arguments:
1722   state           exim_gnutls_state_st *
1723   errstr          error string pointer
1724
1725 Returns:          OK/DEFER/FAIL
1726 */
1727
1728 static int
1729 tls_expand_session_files(exim_gnutls_state_st * state, uschar ** errstr)
1730 {
1731 int rc;
1732 const host_item *host = state->host;  /* macro should be reconsidered? */
1733 const uschar *saved_tls_certificate = NULL;
1734 const uschar *saved_tls_privatekey = NULL;
1735 const uschar *saved_tls_verify_certificates = NULL;
1736 const uschar *saved_tls_crl = NULL;
1737 int cert_count;
1738
1739 /* We check for tls_sni *before* expansion. */
1740 if (!host)      /* server */
1741   if (!state->received_sni)
1742     {
1743     if (  state->tls_certificate
1744        && (  Ustrstr(state->tls_certificate, US"tls_sni")
1745           || Ustrstr(state->tls_certificate, US"tls_in_sni")
1746           || Ustrstr(state->tls_certificate, US"tls_out_sni")
1747        )  )
1748       {
1749       DEBUG(D_tls) debug_printf("We will re-expand TLS session files if we receive SNI\n");
1750       state->trigger_sni_changes = TRUE;
1751       }
1752     }
1753   else  /* SNI callback case */
1754     {
1755     /* useful for debugging */
1756     saved_tls_certificate = state->exp_tls_certificate;
1757     saved_tls_privatekey = state->exp_tls_privatekey;
1758     saved_tls_verify_certificates = state->exp_tls_verify_certificates;
1759     saved_tls_crl = state->exp_tls_crl;
1760     }
1761
1762 if (!state->lib_state.x509_cred)
1763   {
1764   if ((rc = gnutls_certificate_allocate_credentials(
1765         (gnutls_certificate_credentials_t *) &state->lib_state.x509_cred)))
1766     return tls_error_gnu(state, US"gnutls_certificate_allocate_credentials",
1767             rc, errstr);
1768   creds_basic_init(state->lib_state.x509_cred, !host);
1769   }
1770
1771
1772 /* remember: Expand_check_tlsvar() is expand_check() but fiddling with
1773 state members, assuming consistent naming; and expand_check() returns
1774 false if expansion failed, unless expansion was forced to fail. */
1775
1776 /* check if we at least have a certificate, before doing expensive
1777 D-H generation. */
1778
1779 if (!state->lib_state.conn_certs)
1780   {
1781   if (!Expand_check_tlsvar(tls_certificate, errstr))
1782     return DEFER;
1783
1784   /* certificate is mandatory in server, optional in client */
1785
1786   if (  !state->exp_tls_certificate
1787      || !*state->exp_tls_certificate
1788      )
1789     if (!host)
1790       return tls_install_selfsign(state, errstr);
1791     else
1792       DEBUG(D_tls) debug_printf("TLS: no client certificate specified; okay\n");
1793
1794   if (state->tls_privatekey && !Expand_check_tlsvar(tls_privatekey, errstr))
1795     return DEFER;
1796
1797   /* tls_privatekey is optional, defaulting to same file as certificate */
1798
1799   if (!state->tls_privatekey || !*state->tls_privatekey)
1800     {
1801     state->tls_privatekey = state->tls_certificate;
1802     state->exp_tls_privatekey = state->exp_tls_certificate;
1803     }
1804
1805   if (state->exp_tls_certificate && *state->exp_tls_certificate)
1806     {
1807     BOOL load = TRUE;
1808     DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
1809         state->exp_tls_certificate, state->exp_tls_privatekey);
1810
1811     if (state->received_sni)
1812       if (  Ustrcmp(state->exp_tls_certificate, saved_tls_certificate) == 0
1813          && Ustrcmp(state->exp_tls_privatekey,  saved_tls_privatekey)  == 0
1814          )
1815         {
1816         DEBUG(D_tls) debug_printf("TLS SNI: cert and key unchanged\n");
1817         load = FALSE;   /* avoid re-loading the same certs */
1818         }
1819       else              /* unload the pre-SNI certs before loading new ones */
1820         {
1821         DEBUG(D_tls) debug_printf("TLS SNI: have a changed cert/key pair\n");
1822         gnutls_certificate_free_keys(state->lib_state.x509_cred);
1823         }
1824
1825     if (  load
1826        && (rc = host
1827           ? creds_load_client_certs(state, host, state->exp_tls_certificate,
1828                               state->exp_tls_privatekey, errstr)
1829           : creds_load_server_certs(state, state->exp_tls_certificate,
1830                               state->exp_tls_privatekey,
1831 #ifdef DISABLE_OCSP
1832                               NULL,
1833 #else
1834                               tls_ocsp_file,
1835 #endif
1836                               errstr)
1837        )  ) return rc;
1838     }
1839   }
1840 else
1841   {
1842   DEBUG(D_tls)
1843     debug_printf("%s certs were preloaded\n", host ? "client" : "server");
1844
1845   if (!state->tls_privatekey) state->tls_privatekey = state->tls_certificate;
1846   state->exp_tls_certificate = US state->tls_certificate;
1847   state->exp_tls_privatekey = US state->tls_privatekey;
1848
1849 #ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
1850   if (state->lib_state.ocsp_hook)
1851      gnutls_handshake_set_hook_function(state->session,
1852        GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST, tls_server_hook_cb);
1853 #endif
1854   }
1855
1856
1857 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
1858 provided. Experiment shows that, if the certificate file is empty, an unhelpful
1859 error message is provided. However, if we just refrain from setting anything up
1860 in that case, certificate verification fails, which seems to be the correct
1861 behaviour.
1862 If none was configured and we can't handle "system", treat as empty. */
1863
1864 if (!state->lib_state.cabundle)
1865   {
1866   if (state->tls_verify_certificates && *state->tls_verify_certificates)
1867     {
1868     if (!Expand_check_tlsvar(tls_verify_certificates, errstr))
1869       return DEFER;
1870 #ifndef SUPPORT_SYSDEFAULT_CABUNDLE
1871     if (Ustrcmp(state->exp_tls_verify_certificates, "system") == 0)
1872       state->exp_tls_verify_certificates = NULL;
1873 #endif
1874     if (state->tls_crl && *state->tls_crl)
1875       if (!Expand_check_tlsvar(tls_crl, errstr))
1876         return DEFER;
1877
1878     if (!(state->exp_tls_verify_certificates &&
1879           *state->exp_tls_verify_certificates))
1880       {
1881       DEBUG(D_tls)
1882         debug_printf("TLS: tls_verify_certificates expanded empty, ignoring\n");
1883       /* With no tls_verify_certificates, we ignore tls_crl too */
1884       return OK;
1885       }
1886     }
1887   else
1888     {
1889     DEBUG(D_tls)
1890       debug_printf("TLS: tls_verify_certificates not set or empty, ignoring\n");
1891     return OK;
1892     }
1893   rc = creds_load_cabundle(state, state->exp_tls_verify_certificates, host, errstr);
1894   if (rc != OK) return rc;
1895   }
1896 else
1897   {
1898   DEBUG(D_tls)
1899     debug_printf("%s CA bundle was preloaded\n", host ? "client" : "server");
1900   state->exp_tls_verify_certificates = US state->tls_verify_certificates;
1901
1902 #ifdef SUPPORT_CA_DIR
1903 /* Mimic the behaviour with OpenSSL of not advertising a usable-cert list
1904 when using the directory-of-certs config model. */
1905     if (state->lib_state.ca_rdn_emulate)
1906       gnutls_certificate_send_x509_rdn_sequence(state->session, 1);
1907 #endif
1908   }
1909
1910
1911 if (!state->lib_state.crl)
1912   {
1913   if (  state->tls_crl && *state->tls_crl
1914      && state->exp_tls_crl && *state->exp_tls_crl)
1915     return creds_load_crl(state, state->exp_tls_crl, errstr);
1916   }
1917 else
1918   {
1919   DEBUG(D_tls)
1920       debug_printf("%s CRL was preloaded\n", host ? "client" : "server");
1921   state->exp_tls_crl = US state->tls_crl;
1922   }
1923
1924 return OK;
1925 }
1926
1927
1928
1929
1930 /*************************************************
1931 *          Set X.509 state variables             *
1932 *************************************************/
1933
1934 /* In GnuTLS, the registered cert/key are not replaced by a later
1935 set of a cert/key, so for SNI support we need a whole new x509_cred
1936 structure.  Which means various other non-re-expanded pieces of state
1937 need to be re-set in the new struct, so the setting logic is pulled
1938 out to this.
1939
1940 Arguments:
1941   state           exim_gnutls_state_st *
1942   errstr          error string pointer
1943
1944 Returns:          OK/DEFER/FAIL
1945 */
1946
1947 static int
1948 tls_set_remaining_x509(exim_gnutls_state_st *state, uschar ** errstr)
1949 {
1950 int rc;
1951 const host_item *host = state->host;  /* macro should be reconsidered? */
1952
1953 /* Create D-H parameters, or read them from the cache file. This function does
1954 its own SMTP error messaging. This only happens for the server, TLS D-H ignores
1955 client-side params. */
1956
1957 if (!state->host)
1958   {
1959   if (!dh_server_params)
1960     if ((rc = init_server_dh(errstr)) != OK) return rc;
1961
1962   /* Unnecessary & discouraged with 3.6.0 or later, according to docs.  But without it,
1963   no DHE- ciphers are advertised. */
1964   gnutls_certificate_set_dh_params(state->lib_state.x509_cred, dh_server_params);
1965   }
1966
1967 /* Link the credentials to the session. */
1968
1969 if ((rc = gnutls_credentials_set(state->session,
1970             GNUTLS_CRD_CERTIFICATE, state->lib_state.x509_cred)))
1971   return tls_error_gnu(state, US"gnutls_credentials_set", rc, errstr);
1972
1973 return OK;
1974 }
1975
1976 /*************************************************
1977 *            Initialize for GnuTLS               *
1978 *************************************************/
1979
1980
1981 /* Called from both server and client code. In the case of a server, errors
1982 before actual TLS negotiation return DEFER.
1983
1984 Arguments:
1985   host            connected host, if client; NULL if server
1986   ob              tranport options block, if client; NULL if server
1987   require_ciphers tls_require_ciphers setting
1988   caller_state    returned state-info structure
1989   errstr          error string pointer
1990
1991 Returns:          OK/DEFER/FAIL
1992 */
1993
1994 static int
1995 tls_init(
1996     const host_item *host,
1997     smtp_transport_options_block * ob,
1998     const uschar * require_ciphers,
1999     exim_gnutls_state_st **caller_state,
2000     tls_support * tlsp,
2001     uschar ** errstr)
2002 {
2003 exim_gnutls_state_st * state;
2004 int rc;
2005 size_t sz;
2006
2007 if (  !exim_gnutls_base_init_done
2008    && (rc = tls_g_init(errstr)) != OK)
2009   return rc;
2010
2011 if (host)
2012   {
2013   /* For client-side sessions we allocate a context. This lets us run
2014   several in parallel. */
2015
2016   int old_pool = store_pool;
2017   store_pool = POOL_PERM;
2018   state = store_get(sizeof(exim_gnutls_state_st), FALSE);
2019   store_pool = old_pool;
2020
2021   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
2022   state->lib_state = ob->tls_preload;
2023   state->tlsp = tlsp;
2024   DEBUG(D_tls) debug_printf("initialising GnuTLS client session\n");
2025   rc = gnutls_init(&state->session, GNUTLS_CLIENT);
2026
2027   state->tls_certificate =      ob->tls_certificate;
2028   state->tls_privatekey =       ob->tls_privatekey;
2029   state->tls_sni =              ob->tls_sni;
2030   state->tls_verify_certificates = ob->tls_verify_certificates;
2031   state->tls_crl =              ob->tls_crl;
2032   }
2033 else
2034   {
2035   /* Server operations always use the one state_server context.  It is not
2036   shared because we have forked a fresh process for every receive.  However it
2037   can get re-used for successive TLS sessions on a single TCP connection. */
2038
2039   state = &state_server;
2040   state->tlsp = tlsp;
2041   DEBUG(D_tls) debug_printf("initialising GnuTLS server session\n");
2042   rc = gnutls_init(&state->session, GNUTLS_SERVER);
2043
2044   state->tls_certificate =      tls_certificate;
2045   state->tls_privatekey =       tls_privatekey;
2046   state->tls_sni =              NULL;
2047   state->tls_verify_certificates = tls_verify_certificates;
2048   state->tls_crl =              tls_crl;
2049   }
2050 if (rc)
2051   return tls_error_gnu(state, US"gnutls_init", rc, errstr);
2052
2053 state->tls_require_ciphers =    require_ciphers;
2054 state->host = host;
2055
2056 /* This handles the variables that might get re-expanded after TLS SNI;
2057 tls_certificate, tls_privatekey, tls_verify_certificates, tls_crl */
2058
2059 DEBUG(D_tls)
2060   debug_printf("Expanding various TLS configuration options for session credentials\n");
2061 if ((rc = tls_expand_session_files(state, errstr)) != OK) return rc;
2062
2063 /* These are all other parts of the x509_cred handling, since SNI in GnuTLS
2064 requires a new structure afterwards. */
2065
2066 if ((rc = tls_set_remaining_x509(state, errstr)) != OK) return rc;
2067
2068 /* set SNI in client, only */
2069 if (host)
2070   {
2071   if (!expand_check(state->tls_sni, US"tls_out_sni", &state->tlsp->sni, errstr))
2072     return DEFER;
2073   if (state->tlsp->sni && *state->tlsp->sni)
2074     {
2075     DEBUG(D_tls)
2076       debug_printf("Setting TLS client SNI to \"%s\"\n", state->tlsp->sni);
2077     sz = Ustrlen(state->tlsp->sni);
2078     if ((rc = gnutls_server_name_set(state->session,
2079           GNUTLS_NAME_DNS, state->tlsp->sni, sz)))
2080       return tls_error_gnu(state, US"gnutls_server_name_set", rc, errstr);
2081     }
2082   }
2083 else if (state->tls_sni)
2084   DEBUG(D_tls) debug_printf("*** PROBABLY A BUG *** " \
2085       "have an SNI set for a server [%s]\n", state->tls_sni);
2086
2087 if (!state->lib_state.pri_string)
2088   {
2089   const uschar * p = NULL;
2090   const char * errpos;
2091
2092   /* This is the priority string support,
2093   http://www.gnutls.org/manual/html_node/Priority-Strings.html
2094   and replaces gnutls_require_kx, gnutls_require_mac & gnutls_require_protocols.
2095   This was backwards incompatible, but means Exim no longer needs to track
2096   all algorithms and provide string forms for them. */
2097
2098   if (state->tls_require_ciphers && *state->tls_require_ciphers)
2099     {
2100     if (!Expand_check_tlsvar(tls_require_ciphers, errstr))
2101       return DEFER;
2102     if (state->exp_tls_require_ciphers && *state->exp_tls_require_ciphers)
2103       {
2104       p = state->exp_tls_require_ciphers;
2105       DEBUG(D_tls) debug_printf("GnuTLS session cipher/priority \"%s\"\n", p);
2106       }
2107     }
2108
2109   if ((rc = creds_load_pristring(state, p, &errpos)))
2110     return tls_error_gnu(state, string_sprintf(
2111                         "gnutls_priority_init(%s) failed at offset %ld, \"%.6s..\"",
2112                         p, (long)(errpos - CS p), errpos),
2113                     rc, errstr);
2114   }
2115 else
2116   {
2117   DEBUG(D_tls) debug_printf("cipher list preloaded\n");
2118   state->exp_tls_require_ciphers = US state->tls_require_ciphers;
2119   }
2120
2121
2122 if ((rc = gnutls_priority_set(state->session, state->lib_state.pri_cache)))
2123   return tls_error_gnu(state, US"gnutls_priority_set", rc, errstr);
2124
2125 /* This also sets the server ticket expiration time to the same, and
2126 the STEK rotation time to 3x. */
2127
2128 gnutls_db_set_cache_expiration(state->session, ssl_session_timeout);
2129
2130 /* Reduce security in favour of increased compatibility, if the admin
2131 decides to make that trade-off. */
2132 if (gnutls_compat_mode)
2133   {
2134 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
2135   DEBUG(D_tls) debug_printf("lowering GnuTLS security, compatibility mode\n");
2136   gnutls_session_enable_compatibility_mode(state->session);
2137 #else
2138   DEBUG(D_tls) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
2139 #endif
2140   }
2141
2142 *caller_state = state;
2143 return OK;
2144 }
2145
2146
2147
2148 /*************************************************
2149 *            Extract peer information            *
2150 *************************************************/
2151
2152 static const uschar *
2153 cipher_stdname_kcm(gnutls_kx_algorithm_t kx, gnutls_cipher_algorithm_t cipher,
2154   gnutls_mac_algorithm_t mac)
2155 {
2156 uschar cs_id[2];
2157 gnutls_kx_algorithm_t kx_i;
2158 gnutls_cipher_algorithm_t cipher_i;
2159 gnutls_mac_algorithm_t mac_i;
2160
2161 for (size_t i = 0;
2162      gnutls_cipher_suite_info(i, cs_id, &kx_i, &cipher_i, &mac_i, NULL);
2163      i++)
2164   if (kx_i == kx && cipher_i == cipher && mac_i == mac)
2165     return cipher_stdname(cs_id[0], cs_id[1]);
2166 return NULL;
2167 }
2168
2169
2170
2171 /* Called from both server and client code.
2172 Only this is allowed to set state->peerdn and state->have_set_peerdn
2173 and we use that to detect double-calls.
2174
2175 NOTE: the state blocks last while the TLS connection is up, which is fine
2176 for logging in the server side, but for the client side, we log after teardown
2177 in src/deliver.c.  While the session is up, we can twist about states and
2178 repoint tls_* globals, but those variables used for logging or other variable
2179 expansion that happens _after_ delivery need to have a longer life-time.
2180
2181 So for those, we get the data from POOL_PERM; the re-invoke guard keeps us from
2182 doing this more than once per generation of a state context.  We set them in
2183 the state context, and repoint tls_* to them.  After the state goes away, the
2184 tls_* copies of the pointers remain valid and client delivery logging is happy.
2185
2186 tls_certificate_verified is a BOOL, so the tls_peerdn and tls_cipher issues
2187 don't apply.
2188
2189 Arguments:
2190   state           exim_gnutls_state_st *
2191   errstr          pointer to error string
2192
2193 Returns:          OK/DEFER/FAIL
2194 */
2195
2196 static int
2197 peer_status(exim_gnutls_state_st * state, uschar ** errstr)
2198 {
2199 gnutls_session_t session = state->session;
2200 const gnutls_datum_t * cert_list;
2201 int old_pool, rc;
2202 unsigned int cert_list_size = 0;
2203 gnutls_protocol_t protocol;
2204 gnutls_cipher_algorithm_t cipher;
2205 gnutls_kx_algorithm_t kx;
2206 gnutls_mac_algorithm_t mac;
2207 gnutls_certificate_type_t ct;
2208 gnutls_x509_crt_t crt;
2209 uschar * dn_buf;
2210 size_t sz;
2211
2212 if (state->have_set_peerdn)
2213   return OK;
2214 state->have_set_peerdn = TRUE;
2215
2216 state->peerdn = NULL;
2217
2218 /* tls_cipher */
2219 cipher = gnutls_cipher_get(session);
2220 protocol = gnutls_protocol_get_version(session);
2221 mac = gnutls_mac_get(session);
2222 kx =
2223 #ifdef GNUTLS_TLS1_3
2224     protocol >= GNUTLS_TLS1_3 ? 0 :
2225 #endif
2226   gnutls_kx_get(session);
2227
2228 old_pool = store_pool;
2229   {
2230   tls_support * tlsp = state->tlsp;
2231   store_pool = POOL_PERM;
2232
2233 #ifdef SUPPORT_GNUTLS_SESS_DESC
2234     {
2235     gstring * g = NULL;
2236     uschar * s = US gnutls_session_get_desc(session), c;
2237
2238     /* Nikos M suggests we use this by preference.  It returns like:
2239     (TLS1.3)-(ECDHE-SECP256R1)-(RSA-PSS-RSAE-SHA256)-(AES-256-GCM)
2240
2241     For partial back-compat, put a colon after the TLS version, replace the
2242     )-( grouping with __, replace in-group - with _ and append the :keysize. */
2243
2244     /* debug_printf("peer_status: gnutls_session_get_desc %s\n", s); */
2245
2246     for (s++; (c = *s) && c != ')'; s++) g = string_catn(g, s, 1);
2247
2248     tlsp->ver = string_copyn(g->s, g->ptr);
2249     for (uschar * p = US tlsp->ver; *p; p++)
2250       if (*p == '-') { *p = '\0'; break; }      /* TLS1.0-PKIX -> TLS1.0 */
2251
2252     g = string_catn(g, US":", 1);
2253     if (*s) s++;                /* now on _ between groups */
2254     while ((c = *s))
2255       {
2256       for (*++s && ++s; (c = *s) && c != ')'; s++)
2257         g = string_catn(g, c == '-' ? US"_" : s, 1);
2258       /* now on ) closing group */
2259       if ((c = *s) && *++s == '-') g = string_catn(g, US"__", 2);
2260       /* now on _ between groups */
2261       }
2262     g = string_catn(g, US":", 1);
2263     g = string_cat(g, string_sprintf("%d", (int) gnutls_cipher_get_key_size(cipher) * 8));
2264     state->ciphersuite = string_from_gstring(g);
2265     }
2266 #else
2267   state->ciphersuite = string_sprintf("%s:%s:%d",
2268       gnutls_protocol_get_name(protocol),
2269       gnutls_cipher_suite_get_name(kx, cipher, mac),
2270       (int) gnutls_cipher_get_key_size(cipher) * 8);
2271
2272   /* I don't see a way that spaces could occur, in the current GnuTLS
2273   code base, but it was a concern in the old code and perhaps older GnuTLS
2274   releases did return "TLS 1.0"; play it safe, just in case. */
2275
2276   for (uschar * p = state->ciphersuite; *p; p++) if (isspace(*p)) *p = '-';
2277   tlsp->ver = string_copyn(state->ciphersuite,
2278                         Ustrchr(state->ciphersuite, ':') - state->ciphersuite);
2279 #endif
2280
2281 /* debug_printf("peer_status: ciphersuite %s\n", state->ciphersuite); */
2282
2283   tlsp->cipher = state->ciphersuite;
2284   tlsp->bits = gnutls_cipher_get_key_size(cipher) * 8;
2285
2286   tlsp->cipher_stdname = cipher_stdname_kcm(kx, cipher, mac);
2287   }
2288 store_pool = old_pool;
2289
2290 /* tls_peerdn */
2291 cert_list = gnutls_certificate_get_peers(session, &cert_list_size);
2292
2293 if (!cert_list || cert_list_size == 0)
2294   {
2295   DEBUG(D_tls) debug_printf("TLS: no certificate from peer (%p & %d)\n",
2296       cert_list, cert_list_size);
2297   if (state->verify_requirement >= VERIFY_REQUIRED)
2298     return tls_error(US"certificate verification failed",
2299         US"no certificate received from peer", state->host, errstr);
2300   return OK;
2301   }
2302
2303 if ((ct = gnutls_certificate_type_get(session)) != GNUTLS_CRT_X509)
2304   {
2305   const uschar * ctn = US gnutls_certificate_type_get_name(ct);
2306   DEBUG(D_tls)
2307     debug_printf("TLS: peer cert not X.509 but instead \"%s\"\n", ctn);
2308   if (state->verify_requirement >= VERIFY_REQUIRED)
2309     return tls_error(US"certificate verification not possible, unhandled type",
2310         ctn, state->host, errstr);
2311   return OK;
2312   }
2313
2314 #define exim_gnutls_peer_err(Label) \
2315   do { \
2316     if (rc != GNUTLS_E_SUCCESS) \
2317       { \
2318       DEBUG(D_tls) debug_printf("TLS: peer cert problem: %s: %s\n", \
2319         (Label), gnutls_strerror(rc)); \
2320       if (state->verify_requirement >= VERIFY_REQUIRED) \
2321         return tls_error_gnu(state, (Label), rc, errstr); \
2322       return OK; \
2323       } \
2324     } while (0)
2325
2326 rc = import_cert(&cert_list[0], &crt);
2327 exim_gnutls_peer_err(US"cert 0");
2328
2329 state->tlsp->peercert = state->peercert = crt;
2330
2331 sz = 0;
2332 rc = gnutls_x509_crt_get_dn(crt, NULL, &sz);
2333 if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
2334   {
2335   exim_gnutls_peer_err(US"getting size for cert DN failed");
2336   return FAIL; /* should not happen */
2337   }
2338 dn_buf = store_get_perm(sz, TRUE);      /* tainted */
2339 rc = gnutls_x509_crt_get_dn(crt, CS dn_buf, &sz);
2340 exim_gnutls_peer_err(US"failed to extract certificate DN [gnutls_x509_crt_get_dn(cert 0)]");
2341
2342 state->peerdn = dn_buf;
2343
2344 return OK;
2345 #undef exim_gnutls_peer_err
2346 }
2347
2348
2349
2350
2351 /*************************************************
2352 *            Verify peer certificate             *
2353 *************************************************/
2354
2355 /* Called from both server and client code.
2356 *Should* be using a callback registered with
2357 gnutls_certificate_set_verify_function() to fail the handshake if we dislike
2358 the peer information, but that's too new for some OSes.
2359
2360 Arguments:
2361   state         exim_gnutls_state_st *
2362   errstr        where to put an error message
2363
2364 Returns:
2365   FALSE     if the session should be rejected
2366   TRUE      if the cert is okay or we just don't care
2367 */
2368
2369 static BOOL
2370 verify_certificate(exim_gnutls_state_st * state, uschar ** errstr)
2371 {
2372 int rc;
2373 uint verify;
2374
2375 DEBUG(D_tls) debug_printf("TLS: checking peer certificate\n");
2376 *errstr = NULL;
2377 rc = peer_status(state, errstr);
2378
2379 if (state->verify_requirement == VERIFY_NONE)
2380   return TRUE;
2381
2382 if (rc != OK || !state->peerdn)
2383   {
2384   verify = GNUTLS_CERT_INVALID;
2385   *errstr = US"certificate not supplied";
2386   }
2387 else
2388
2389   {
2390 #ifdef SUPPORT_DANE
2391   if (state->verify_requirement == VERIFY_DANE && state->host)
2392     {
2393     /* Using dane_verify_session_crt() would be easy, as it does it all for us
2394     including talking to a DNS resolver.  But we want to do that bit ourselves
2395     as the testsuite intercepts and fakes its own DNS environment. */
2396
2397     dane_state_t s;
2398     dane_query_t r;
2399     uint lsize;
2400     const gnutls_datum_t * certlist =
2401       gnutls_certificate_get_peers(state->session, &lsize);
2402     int usage = tls_out.tlsa_usage;
2403
2404 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
2405     /* Split the TLSA records into two sets, TA and EE selectors.  Run the
2406     dane-verification separately so that we know which selector verified;
2407     then we know whether to do name-verification (needed for TA but not EE). */
2408
2409     if (usage == ((1<<DANESSL_USAGE_DANE_TA) | (1<<DANESSL_USAGE_DANE_EE)))
2410       {                                         /* a mixed-usage bundle */
2411       int i, j, nrec;
2412       const char ** dd;
2413       int * ddl;
2414
2415       for (nrec = 0; state->dane_data_len[nrec]; ) nrec++;
2416       nrec++;
2417
2418       dd = store_get(nrec * sizeof(uschar *), FALSE);
2419       ddl = store_get(nrec * sizeof(int), FALSE);
2420       nrec--;
2421
2422       if ((rc = dane_state_init(&s, 0)))
2423         goto tlsa_prob;
2424
2425       for (usage = DANESSL_USAGE_DANE_EE;
2426            usage >= DANESSL_USAGE_DANE_TA; usage--)
2427         {                               /* take records with this usage */
2428         for (j = i = 0; i < nrec; i++)
2429           if (state->dane_data[i][0] == usage)
2430             {
2431             dd[j] = state->dane_data[i];
2432             ddl[j++] = state->dane_data_len[i];
2433             }
2434         if (j)
2435           {
2436           dd[j] = NULL;
2437           ddl[j] = 0;
2438
2439           if ((rc = dane_raw_tlsa(s, &r, (char * const *)dd, ddl, 1, 0)))
2440             goto tlsa_prob;
2441
2442           if ((rc = dane_verify_crt_raw(s, certlist, lsize,
2443                             gnutls_certificate_type_get(state->session),
2444                             r, 0,
2445                             usage == DANESSL_USAGE_DANE_EE
2446                             ? DANE_VFLAG_ONLY_CHECK_EE_USAGE : 0,
2447                             &verify)))
2448             {
2449             DEBUG(D_tls)
2450               debug_printf("TLSA record problem: %s\n", dane_strerror(rc));
2451             }
2452           else if (verify == 0) /* verification passed */
2453             {
2454             usage = 1 << usage;
2455             break;
2456             }
2457           }
2458         }
2459
2460         if (rc) goto tlsa_prob;
2461       }
2462     else
2463 # endif
2464       {
2465       if (  (rc = dane_state_init(&s, 0))
2466          || (rc = dane_raw_tlsa(s, &r, state->dane_data, state->dane_data_len,
2467                         1, 0))
2468          || (rc = dane_verify_crt_raw(s, certlist, lsize,
2469                         gnutls_certificate_type_get(state->session),
2470                         r, 0,
2471 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
2472                         usage == (1 << DANESSL_USAGE_DANE_EE)
2473                         ? DANE_VFLAG_ONLY_CHECK_EE_USAGE : 0,
2474 # else
2475                         0,
2476 # endif
2477                         &verify))
2478          )
2479         goto tlsa_prob;
2480       }
2481
2482     if (verify != 0)            /* verification failed */
2483       {
2484       gnutls_datum_t str;
2485       (void) dane_verification_status_print(verify, &str, 0);
2486       *errstr = US str.data;    /* don't bother to free */
2487       goto badcert;
2488       }
2489
2490 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
2491     /* If a TA-mode TLSA record was used for verification we must additionally
2492     verify the cert name (but not the CA chain).  For EE-mode, skip it. */
2493
2494     if (usage & (1 << DANESSL_USAGE_DANE_EE))
2495 # endif
2496       {
2497       state->peer_dane_verified = state->peer_cert_verified = TRUE;
2498       goto goodcert;
2499       }
2500 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
2501     /* Assume that the name on the A-record is the one that should be matching
2502     the cert.  An alternate view is that the domain part of the email address
2503     is also permissible. */
2504
2505     if (gnutls_x509_crt_check_hostname(state->tlsp->peercert,
2506           CS state->host->name))
2507       {
2508       state->peer_dane_verified = state->peer_cert_verified = TRUE;
2509       goto goodcert;
2510       }
2511 # endif
2512     }
2513 #endif  /*SUPPORT_DANE*/
2514
2515   rc = gnutls_certificate_verify_peers2(state->session, &verify);
2516   }
2517
2518 /* Handle the result of verification. INVALID is set if any others are. */
2519
2520 if (rc < 0 || verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
2521   {
2522   state->peer_cert_verified = FALSE;
2523   if (!*errstr)
2524     {
2525 #ifdef GNUTLS_CERT_VFY_STATUS_PRINT
2526     DEBUG(D_tls)
2527       {
2528       gnutls_datum_t txt;
2529
2530       if (gnutls_certificate_verification_status_print(verify,
2531             gnutls_certificate_type_get(state->session), &txt, 0)
2532           == GNUTLS_E_SUCCESS)
2533         {
2534         debug_printf("%s\n", txt.data);
2535         gnutls_free(txt.data);
2536         }
2537       }
2538 #endif
2539     *errstr = verify & GNUTLS_CERT_REVOKED
2540       ? US"certificate revoked" : US"certificate invalid";
2541     }
2542
2543   DEBUG(D_tls)
2544     debug_printf("TLS certificate verification failed (%s): peerdn=\"%s\"\n",
2545         *errstr, state->peerdn ? state->peerdn : US"<unset>");
2546
2547   if (state->verify_requirement >= VERIFY_REQUIRED)
2548     goto badcert;
2549   DEBUG(D_tls)
2550     debug_printf("TLS verify failure overridden (host in tls_try_verify_hosts)\n");
2551   }
2552
2553 else
2554   {
2555   /* Client side, check the server's certificate name versus the name on the
2556   A-record for the connection we made.  What to do for server side - what name
2557   to use for client?  We document that there is no such checking for server
2558   side. */
2559
2560   if (  state->exp_tls_verify_cert_hostnames
2561      && !gnutls_x509_crt_check_hostname(state->tlsp->peercert,
2562                 CS state->exp_tls_verify_cert_hostnames)
2563      )
2564     {
2565     DEBUG(D_tls)
2566       debug_printf("TLS certificate verification failed: cert name mismatch\n");
2567     if (state->verify_requirement >= VERIFY_REQUIRED)
2568       goto badcert;
2569     return TRUE;
2570     }
2571
2572   state->peer_cert_verified = TRUE;
2573   DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=\"%s\"\n",
2574       state->peerdn ? state->peerdn : US"<unset>");
2575   }
2576
2577 goodcert:
2578   state->tlsp->peerdn = state->peerdn;
2579   return TRUE;
2580
2581 #ifdef SUPPORT_DANE
2582 tlsa_prob:
2583   *errstr = string_sprintf("TLSA record problem: %s",
2584     rc == DANE_E_REQUESTED_DATA_NOT_AVAILABLE ? "none usable" : dane_strerror(rc));
2585 #endif
2586
2587 badcert:
2588   gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
2589   return FALSE;
2590 }
2591
2592
2593
2594
2595 /* ------------------------------------------------------------------------ */
2596 /* Callbacks */
2597
2598 /* Logging function which can be registered with
2599  *   gnutls_global_set_log_function()
2600  *   gnutls_global_set_log_level() 0..9
2601  */
2602 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
2603 static void
2604 exim_gnutls_logger_cb(int level, const char *message)
2605 {
2606   size_t len = strlen(message);
2607   if (len < 1)
2608     {
2609     DEBUG(D_tls) debug_printf("GnuTLS<%d> empty debug message\n", level);
2610     return;
2611     }
2612   DEBUG(D_tls) debug_printf("GnuTLS<%d>: %s%s", level, message,
2613       message[len-1] == '\n' ? "" : "\n");
2614 }
2615 #endif
2616
2617
2618 /* Called after client hello, should handle SNI work.
2619 This will always set tls_sni (state->received_sni) if available,
2620 and may trigger presenting different certificates,
2621 if state->trigger_sni_changes is TRUE.
2622
2623 Should be registered with
2624   gnutls_handshake_set_post_client_hello_function()
2625
2626 "This callback must return 0 on success or a gnutls error code to terminate the
2627 handshake.".
2628
2629 For inability to get SNI information, we return 0.
2630 We only return non-zero if re-setup failed.
2631 Only used for server-side TLS.
2632 */
2633
2634 static int
2635 exim_sni_handling_cb(gnutls_session_t session)
2636 {
2637 char sni_name[MAX_HOST_LEN];
2638 size_t data_len = MAX_HOST_LEN;
2639 exim_gnutls_state_st *state = &state_server;
2640 unsigned int sni_type;
2641 int rc, old_pool;
2642 uschar * dummy_errstr;
2643
2644 rc = gnutls_server_name_get(session, sni_name, &data_len, &sni_type, 0);
2645 if (rc != GNUTLS_E_SUCCESS)
2646   {
2647   DEBUG(D_tls)
2648     if (rc == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
2649       debug_printf("TLS: no SNI presented in handshake\n");
2650     else
2651       debug_printf("TLS failure: gnutls_server_name_get(): %s [%d]\n",
2652         gnutls_strerror(rc), rc);
2653   return 0;
2654   }
2655
2656 if (sni_type != GNUTLS_NAME_DNS)
2657   {
2658   DEBUG(D_tls) debug_printf("TLS: ignoring SNI of unhandled type %u\n", sni_type);
2659   return 0;
2660   }
2661
2662 /* We now have a UTF-8 string in sni_name */
2663 old_pool = store_pool;
2664 store_pool = POOL_PERM;
2665 state->received_sni = string_copy_taint(US sni_name, TRUE);
2666 store_pool = old_pool;
2667
2668 /* We set this one now so that variable expansions below will work */
2669 state->tlsp->sni = state->received_sni;
2670
2671 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", sni_name,
2672     state->trigger_sni_changes ? "" : " (unused for certificate selection)");
2673
2674 if (!state->trigger_sni_changes)
2675   return 0;
2676
2677 if ((rc = tls_expand_session_files(state, &dummy_errstr)) != OK)
2678   {
2679   /* If the setup of certs/etc failed before handshake, TLS would not have
2680   been offered.  The best we can do now is abort. */
2681   return GNUTLS_E_APPLICATION_ERROR_MIN;
2682   }
2683
2684 rc = tls_set_remaining_x509(state, &dummy_errstr);
2685 if (rc != OK) return GNUTLS_E_APPLICATION_ERROR_MIN;
2686
2687 return 0;
2688 }
2689
2690
2691
2692 #ifndef DISABLE_EVENT
2693 /*
2694 We use this callback to get observability and detail-level control
2695 for an exim TLS connection (either direction), raising a tls:cert event
2696 for each cert in the chain presented by the peer.  Any event
2697 can deny verification.
2698
2699 Return 0 for the handshake to continue or non-zero to terminate.
2700 */
2701
2702 static int
2703 verify_cb(gnutls_session_t session)
2704 {
2705 const gnutls_datum_t * cert_list;
2706 unsigned int cert_list_size = 0;
2707 gnutls_x509_crt_t crt;
2708 int rc;
2709 uschar * yield;
2710 exim_gnutls_state_st * state = gnutls_session_get_ptr(session);
2711
2712 if ((cert_list = gnutls_certificate_get_peers(session, &cert_list_size)))
2713   while (cert_list_size--)
2714   {
2715   if ((rc = import_cert(&cert_list[cert_list_size], &crt)) != GNUTLS_E_SUCCESS)
2716     {
2717     DEBUG(D_tls) debug_printf("TLS: peer cert problem: depth %d: %s\n",
2718       cert_list_size, gnutls_strerror(rc));
2719     break;
2720     }
2721
2722   state->tlsp->peercert = crt;
2723   if ((yield = event_raise(state->event_action,
2724               US"tls:cert", string_sprintf("%d", cert_list_size))))
2725     {
2726     log_write(0, LOG_MAIN,
2727               "SSL verify denied by event-action: depth=%d: %s",
2728               cert_list_size, yield);
2729     return 1;                     /* reject */
2730     }
2731   state->tlsp->peercert = NULL;
2732   }
2733
2734 return 0;
2735 }
2736
2737 #endif
2738
2739
2740 static gstring *
2741 ddump(gnutls_datum_t * d)
2742 {
2743 gstring * g = string_get((d->size+1) * 2);
2744 uschar * s = d->data;
2745 for (unsigned i = d->size; i > 0; i--, s++)
2746   {
2747   g = string_catn(g, US "0123456789abcdef" + (*s >> 4), 1);
2748   g = string_catn(g, US "0123456789abcdef" + (*s & 0xf), 1);
2749   }
2750 return g;
2751 }
2752
2753 static void
2754 post_handshake_debug(exim_gnutls_state_st * state)
2755 {
2756 #ifdef SUPPORT_GNUTLS_SESS_DESC
2757 debug_printf("%s\n", gnutls_session_get_desc(state->session));
2758 #endif
2759
2760 #ifdef SUPPORT_GNUTLS_KEYLOG
2761 # ifdef EXIM_HAVE_TLS1_3
2762 if (gnutls_protocol_get_version(state->session) < GNUTLS_TLS1_3)
2763 # else
2764 if (TRUE)
2765 # endif
2766   {
2767   gnutls_datum_t c, s;
2768   gstring * gc, * gs;
2769   /* For TLS1.2 we only want the client random and the master secret */
2770   gnutls_session_get_random(state->session, &c, &s);
2771   gnutls_session_get_master_secret(state->session, &s);
2772   gc = ddump(&c);
2773   gs = ddump(&s);
2774   debug_printf("CLIENT_RANDOM %.*s %.*s\n", (int)gc->ptr, gc->s, (int)gs->ptr, gs->s);
2775   }
2776 else
2777   debug_printf("To get keying info for TLS1.3 is hard:\n"
2778     " Set environment variable SSLKEYLOGFILE to a filename relative to the spool directory,\n"
2779     " and make sure it is writable by the Exim runtime user.\n"
2780     " Add SSLKEYLOGFILE to keep_environment in the exim config.\n"
2781     " Start Exim as root.\n"
2782     " If using sudo, add SSLKEYLOGFILE to env_keep in /etc/sudoers\n"
2783     " (works for TLS1.2 also, and saves cut-paste into file).\n"
2784     " Trying to use add_environment for this will not work\n");
2785 #endif
2786 }
2787
2788
2789 #ifdef EXIM_HAVE_TLS_RESUME
2790 static int
2791 tls_server_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
2792   unsigned incoming, const gnutls_datum_t * msg)
2793 {
2794 DEBUG(D_tls) debug_printf("newticket cb\n");
2795 tls_in.resumption |= RESUME_CLIENT_REQUESTED;
2796 return 0;
2797 }
2798
2799 static void
2800 tls_server_resume_prehandshake(exim_gnutls_state_st * state)
2801 {
2802 /* Should the server offer session resumption? */
2803 tls_in.resumption = RESUME_SUPPORTED;
2804 if (verify_check_host(&tls_resumption_hosts) == OK)
2805   {
2806   int rc;
2807   /* GnuTLS appears to not do ticket overlap, but does emit a fresh ticket when
2808   an offered resumption is unacceptable.  We lose one resumption per ticket
2809   lifetime, and sessions cannot be indefinitely re-used.  There seems to be no
2810   way (3.6.7) of changing the default number of 2 TLS1.3 tickets issued, but at
2811   least they go out in a single packet. */
2812
2813   if (!(rc = gnutls_session_ticket_enable_server(state->session,
2814               &server_sessticket_key)))
2815     tls_in.resumption |= RESUME_SERVER_TICKET;
2816   else
2817     DEBUG(D_tls)
2818       debug_printf("enabling session tickets: %s\n", US gnutls_strerror(rc));
2819
2820   /* Try to tell if we see a ticket request */
2821   gnutls_handshake_set_hook_function(state->session,
2822     GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST, tls_server_hook_cb);
2823   }
2824 }
2825
2826 static void
2827 tls_server_resume_posthandshake(exim_gnutls_state_st * state)
2828 {
2829 if (gnutls_session_resumption_requested(state->session))
2830   {
2831   /* This tells us the client sent a full ticket.  We use a
2832   callback on session-ticket request, elsewhere, to tell
2833   if a client asked for a ticket. */
2834
2835   tls_in.resumption |= RESUME_CLIENT_SUGGESTED;
2836   DEBUG(D_tls) debug_printf("client requested resumption\n");
2837   }
2838 if (gnutls_session_is_resumed(state->session))
2839   {
2840   tls_in.resumption |= RESUME_USED;
2841   DEBUG(D_tls) debug_printf("Session resumed\n");
2842   }
2843 }
2844 #endif  /* EXIM_HAVE_TLS_RESUME */
2845
2846
2847 #ifdef EXIM_HAVE_ALPN
2848 /* Expand and convert an Exim list to a gnutls_datum list.  False return for fail.
2849 NULL plist return for silent no-ALPN.
2850 */
2851
2852 static BOOL
2853 tls_alpn_plist(const uschar * tls_alpn, const gnutls_datum_t ** plist, unsigned * plen,
2854   uschar ** errstr)
2855 {
2856 uschar * exp_alpn;
2857
2858 if (!expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr))
2859   return FALSE;
2860
2861 if (!exp_alpn)
2862   {
2863   DEBUG(D_tls) debug_printf("Setting TLS ALPN forced to fail, not sending\n");
2864   *plist = NULL;
2865   }
2866 else
2867   {
2868   const uschar * list = exp_alpn;
2869   int sep = 0;
2870   unsigned cnt = 0;
2871   gnutls_datum_t * p;
2872   uschar * s;
2873
2874   while (string_nextinlist(&list, &sep, NULL, 0)) cnt++;
2875
2876   p = store_get(sizeof(gnutls_datum_t) * cnt, is_tainted(exp_alpn));
2877   list = exp_alpn;
2878   for (int i = 0; s = string_nextinlist(&list, &sep, NULL, 0); i++)
2879     { p[i].data = s; p[i].size = Ustrlen(s); }
2880   *plist = (*plen = cnt) ? p : NULL;
2881   }
2882 return TRUE;
2883 }
2884
2885 static void
2886 tls_server_set_acceptable_alpns(exim_gnutls_state_st * state, uschar ** errstr)
2887 {
2888 int rc;
2889 const gnutls_datum_t * plist;
2890 unsigned plen;
2891
2892 if (tls_alpn_plist(tls_alpn, &plist, &plen, errstr) && plist)
2893   {
2894   /* This seems to be only mandatory if the client sends an ALPN extension;
2895   not trying ALPN is ok. Need to decide how to support server-side must-alpn. */
2896
2897   server_seen_alpn = 0;
2898   if (!(rc = gnutls_alpn_set_protocols(state->session, plist, plen,
2899                                         GNUTLS_ALPN_MANDATORY)))
2900     gnutls_handshake_set_hook_function(state->session,
2901       GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST, tls_server_hook_cb);
2902   else
2903     DEBUG(D_tls)
2904       debug_printf("setting alpn protocols: %s\n", US gnutls_strerror(rc));
2905   }
2906 }
2907 #endif  /* EXIM_HAVE_ALPN */
2908
2909 /* ------------------------------------------------------------------------ */
2910 /* Exported functions */
2911
2912
2913
2914
2915 /*************************************************
2916 *       Start a TLS session in a server          *
2917 *************************************************/
2918
2919 /* This is called when Exim is running as a server, after having received
2920 the STARTTLS command. It must respond to that command, and then negotiate
2921 a TLS session.
2922
2923 Arguments:
2924   errstr           pointer to error string
2925
2926 Returns:           OK on success
2927                    DEFER for errors before the start of the negotiation
2928                    FAIL for errors during the negotiation; the server can't
2929                      continue running.
2930 */
2931
2932 int
2933 tls_server_start(uschar ** errstr)
2934 {
2935 int rc;
2936 exim_gnutls_state_st * state = NULL;
2937
2938 /* Check for previous activation */
2939 if (tls_in.active.sock >= 0)
2940   {
2941   tls_error(US"STARTTLS received after TLS started", US "", NULL, errstr);
2942   smtp_printf("554 Already in TLS\r\n", FALSE);
2943   return FAIL;
2944   }
2945
2946 /* Initialize the library. If it fails, it will already have logged the error
2947 and sent an SMTP response. */
2948
2949 DEBUG(D_tls) debug_printf("initialising GnuTLS as a server\n");
2950
2951   {
2952 #ifdef MEASURE_TIMING
2953   struct timeval t0;
2954   gettimeofday(&t0, NULL);
2955 #endif
2956
2957   if ((rc = tls_init(NULL, NULL,
2958       tls_require_ciphers, &state, &tls_in, errstr)) != OK) return rc;
2959
2960 #ifdef MEASURE_TIMING
2961   report_time_since(&t0, US"server tls_init (delta)");
2962 #endif
2963   }
2964
2965 #ifdef EXIM_HAVE_ALPN
2966 tls_server_set_acceptable_alpns(state, errstr);
2967 #endif
2968
2969 #ifdef EXIM_HAVE_TLS_RESUME
2970 tls_server_resume_prehandshake(state);
2971 #endif
2972
2973 /* If this is a host for which certificate verification is mandatory or
2974 optional, set up appropriately. */
2975
2976 if (verify_check_host(&tls_verify_hosts) == OK)
2977   {
2978   DEBUG(D_tls)
2979     debug_printf("TLS: a client certificate will be required\n");
2980   state->verify_requirement = VERIFY_REQUIRED;
2981   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
2982   }
2983 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2984   {
2985   DEBUG(D_tls)
2986     debug_printf("TLS: a client certificate will be requested but not required\n");
2987   state->verify_requirement = VERIFY_OPTIONAL;
2988   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
2989   }
2990 else
2991   {
2992   DEBUG(D_tls)
2993     debug_printf("TLS: a client certificate will not be requested\n");
2994   state->verify_requirement = VERIFY_NONE;
2995   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
2996   }
2997
2998 #ifndef DISABLE_EVENT
2999 if (event_action)
3000   {
3001   state->event_action = event_action;
3002   gnutls_session_set_ptr(state->session, state);
3003   gnutls_certificate_set_verify_function(state->lib_state.x509_cred, verify_cb);
3004   }
3005 #endif
3006
3007 /* Register SNI handling; always, even if not in tls_certificate, so that the
3008 expansion variable $tls_sni is always available. */
3009
3010 gnutls_handshake_set_post_client_hello_function(state->session,
3011     exim_sni_handling_cb);
3012
3013 /* Set context and tell client to go ahead, except in the case of TLS startup
3014 on connection, where outputting anything now upsets the clients and tends to
3015 make them disconnect. We need to have an explicit fflush() here, to force out
3016 the response. Other smtp_printf() calls do not need it, because in non-TLS
3017 mode, the fflush() happens when smtp_getc() is called. */
3018
3019 if (!state->tlsp->on_connect)
3020   {
3021   smtp_printf("220 TLS go ahead\r\n", FALSE);
3022   fflush(smtp_out);
3023   }
3024
3025 /* Now negotiate the TLS session. We put our own timer on it, since it seems
3026 that the GnuTLS library doesn't.
3027 From 3.1.0 there is gnutls_handshake_set_timeout() - but it requires you
3028 to set (and clear down afterwards) up a pull-timeout callback function that does
3029 a select, so we're no better off unless avoiding signals becomes an issue. */
3030
3031 gnutls_transport_set_ptr2(state->session,
3032     (gnutls_transport_ptr_t)(long) fileno(smtp_in),
3033     (gnutls_transport_ptr_t)(long) fileno(smtp_out));
3034 state->fd_in = fileno(smtp_in);
3035 state->fd_out = fileno(smtp_out);
3036
3037 sigalrm_seen = FALSE;
3038 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3039 do
3040   rc = gnutls_handshake(state->session);
3041 while (rc == GNUTLS_E_AGAIN ||  rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen);
3042 ALARM_CLR(0);
3043
3044 if (rc != GNUTLS_E_SUCCESS)
3045   {
3046   /* It seems that, except in the case of a timeout, we have to close the
3047   connection right here; otherwise if the other end is running OpenSSL it hangs
3048   until the server times out. */
3049
3050   if (sigalrm_seen)
3051     {
3052     tls_error(US"gnutls_handshake", US"timed out", NULL, errstr);
3053     gnutls_db_remove_session(state->session);
3054     }
3055   else
3056     {
3057     tls_error_gnu(state, US"gnutls_handshake", rc, errstr);
3058     (void) gnutls_alert_send_appropriate(state->session, rc);
3059     gnutls_deinit(state->session);
3060     gnutls_certificate_free_credentials(state->lib_state.x509_cred);
3061     state->lib_state = null_tls_preload;
3062     millisleep(500);
3063     shutdown(state->fd_out, SHUT_WR);
3064     for (int i = 1024; fgetc(smtp_in) != EOF && i > 0; ) i--;   /* drain skt */
3065     (void)fclose(smtp_out);
3066     (void)fclose(smtp_in);
3067     smtp_out = smtp_in = NULL;
3068     }
3069
3070   return FAIL;
3071   }
3072
3073 #ifdef GNUTLS_SFLAGS_EXT_MASTER_SECRET
3074 if (gnutls_session_get_flags(state->session) & GNUTLS_SFLAGS_EXT_MASTER_SECRET)
3075   tls_in.ext_master_secret = TRUE;
3076 #endif
3077
3078 #ifdef EXIM_HAVE_TLS_RESUME
3079 tls_server_resume_posthandshake(state);
3080 #endif
3081
3082 DEBUG(D_tls) post_handshake_debug(state);
3083
3084 #ifdef EXIM_HAVE_ALPN
3085 if (server_seen_alpn > 0)
3086   {
3087   DEBUG(D_tls)
3088     {           /* The client offered ALPN.  See what was negotiated. */
3089     gnutls_datum_t p = {.size = 0};
3090     int rc = gnutls_alpn_get_selected_protocol(state->session, &p);
3091     if (!rc)
3092         debug_printf("ALPN negotiated: %.*s\n", (int)p.size, p.data);
3093     else
3094         debug_printf("getting alpn protocol: %s\n", US gnutls_strerror(rc));
3095
3096     }
3097   }
3098 else if (server_seen_alpn == 0)
3099   if (verify_check_host(&hosts_require_alpn) == OK)
3100     {
3101     gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_NO_APPLICATION_PROTOCOL);
3102     tls_error(US"handshake", US"ALPN required but not negotiated", NULL, errstr);
3103     return FAIL;
3104     }
3105   else
3106     DEBUG(D_tls) debug_printf("TLS: no ALPN presented in handshake\n");
3107 else
3108   DEBUG(D_tls) debug_printf("TLS: was not watching for ALPN\n");
3109 #endif
3110
3111 /* Verify after the fact */
3112
3113 if (!verify_certificate(state, errstr))
3114   {
3115   if (state->verify_requirement != VERIFY_OPTIONAL)
3116     {
3117     (void) tls_error(US"certificate verification failed", *errstr, NULL, errstr);
3118     return FAIL;
3119     }
3120   DEBUG(D_tls)
3121     debug_printf("TLS: continuing on only because verification was optional, after: %s\n",
3122         *errstr);
3123   }
3124
3125 /* Sets various Exim expansion variables; always safe within server */
3126
3127 extract_exim_vars_from_tls_state(state);
3128
3129 /* TLS has been set up. Adjust the input functions to read via TLS,
3130 and initialize appropriately. */
3131
3132 state->xfer_buffer = store_malloc(ssl_xfer_buffer_size);
3133
3134 receive_getc = tls_getc;
3135 receive_getbuf = tls_getbuf;
3136 receive_get_cache = tls_get_cache;
3137 receive_hasc = tls_hasc;
3138 receive_ungetc = tls_ungetc;
3139 receive_feof = tls_feof;
3140 receive_ferror = tls_ferror;
3141 receive_smtp_buffered = tls_smtp_buffered;
3142
3143 return OK;
3144 }
3145
3146
3147
3148
3149 static void
3150 tls_client_setup_hostname_checks(host_item * host, exim_gnutls_state_st * state,
3151   smtp_transport_options_block * ob)
3152 {
3153 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
3154   {
3155   state->exp_tls_verify_cert_hostnames =
3156 #ifdef SUPPORT_I18N
3157     string_domain_utf8_to_alabel(host->certname, NULL);
3158 #else
3159     host->certname;
3160 #endif
3161   DEBUG(D_tls)
3162     debug_printf("TLS: server cert verification includes hostname: \"%s\"\n",
3163                     state->exp_tls_verify_cert_hostnames);
3164   }
3165 }
3166
3167
3168
3169
3170 #ifdef SUPPORT_DANE
3171 /* Given our list of RRs from the TLSA lookup, build a lookup block in
3172 GnuTLS-DANE's preferred format.  Hang it on the state str for later
3173 use in DANE verification.
3174
3175 We point at the dnsa data not copy it, so it must remain valid until
3176 after verification is done.*/
3177
3178 static BOOL
3179 dane_tlsa_load(exim_gnutls_state_st * state, dns_answer * dnsa)
3180 {
3181 dns_scan dnss;
3182 int i;
3183 const char **   dane_data;
3184 int *           dane_data_len;
3185
3186 i = 1;
3187 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3188      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3189     ) if (rr->type == T_TLSA) i++;
3190
3191 dane_data = store_get(i * sizeof(uschar *), FALSE);
3192 dane_data_len = store_get(i * sizeof(int), FALSE);
3193
3194 i = 0;
3195 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3196      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3197     ) if (rr->type == T_TLSA && rr->size > 3)
3198   {
3199   const uschar * p = rr->data;
3200 /*XXX need somehow to mark rr and its data as tainted.  Doues this mean copying it? */
3201   uint8_t usage = p[0], sel = p[1], type = p[2];
3202
3203   DEBUG(D_tls)
3204     debug_printf("TLSA: %d %d %d size %d\n", usage, sel, type, rr->size);
3205
3206   if (  (usage != DANESSL_USAGE_DANE_TA && usage != DANESSL_USAGE_DANE_EE)
3207      || (sel != 0 && sel != 1)
3208      )
3209     continue;
3210   switch(type)
3211     {
3212     case 0:     /* Full: cannot check at present */
3213                 break;
3214     case 1:     if (rr->size != 3 + 256/8) continue;    /* sha2-256 */
3215                 break;
3216     case 2:     if (rr->size != 3 + 512/8) continue;    /* sha2-512 */
3217                 break;
3218     default:    continue;
3219     }
3220
3221   tls_out.tlsa_usage |= 1<<usage;
3222   dane_data[i] = CS p;
3223   dane_data_len[i++] = rr->size;
3224   }
3225
3226 if (!i) return FALSE;
3227
3228 dane_data[i] = NULL;
3229 dane_data_len[i] = 0;
3230
3231 state->dane_data = (char * const *)dane_data;
3232 state->dane_data_len = dane_data_len;
3233 return TRUE;
3234 }
3235 #endif
3236
3237
3238
3239 #ifdef EXIM_HAVE_TLS_RESUME
3240 /* On the client, get any stashed session for the given IP from hints db
3241 and apply it to the ssl-connection for attempted resumption.  Although
3242 there is a gnutls_session_ticket_enable_client() interface it is
3243 documented as unnecessary (as of 3.6.7) as "session tickets are emabled
3244 by deafult".  There seems to be no way to disable them, so even hosts not
3245 enabled by the transport option will be sent a ticket request.  We will
3246 however avoid storing and retrieving session information. */
3247
3248 static void
3249 tls_retrieve_session(tls_support * tlsp, gnutls_session_t session,
3250   host_item * host, smtp_transport_options_block * ob)
3251 {
3252 tlsp->resumption = RESUME_SUPPORTED;
3253 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
3254   {
3255   dbdata_tls_session * dt;
3256   int len, rc;
3257   open_db dbblock, * dbm_file;
3258
3259   DEBUG(D_tls)
3260     debug_printf("check for resumable session for %s\n", host->address);
3261   tlsp->host_resumable = TRUE;
3262   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
3263   if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
3264     {
3265     /* Key for the db is the IP.  We'd like to filter the retrieved session
3266     for ticket advisory expiry, but 3.6.1 seems to give no access to that */
3267
3268     if ((dt = dbfn_read_with_length(dbm_file, host->address, &len)))
3269       if (!(rc = gnutls_session_set_data(session,
3270                     CUS dt->session, (size_t)len - sizeof(dbdata_tls_session))))
3271         {
3272         DEBUG(D_tls) debug_printf("good session\n");
3273         tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
3274         }
3275       else DEBUG(D_tls) debug_printf("setting session resumption data: %s\n",
3276             US gnutls_strerror(rc));
3277     dbfn_close(dbm_file);
3278     }
3279   }
3280 }
3281
3282
3283 static void
3284 tls_save_session(tls_support * tlsp, gnutls_session_t session, const host_item * host)
3285 {
3286 /* TLS 1.2 - we get both the callback and the direct posthandshake call,
3287 but this flag is not set until the second.  TLS 1.3 it's the other way about.
3288 Keep both calls as the session data cannot be extracted before handshake
3289 completes. */
3290
3291 if (gnutls_session_get_flags(session) & GNUTLS_SFLAGS_SESSION_TICKET)
3292   {
3293   gnutls_datum_t tkt;
3294   int rc;
3295
3296   DEBUG(D_tls) debug_printf("server offered session ticket\n");
3297   tlsp->ticket_received = TRUE;
3298   tlsp->resumption |= RESUME_SERVER_TICKET;
3299
3300   if (tlsp->host_resumable)
3301     if (!(rc = gnutls_session_get_data2(session, &tkt)))
3302       {
3303       open_db dbblock, * dbm_file;
3304       int dlen = sizeof(dbdata_tls_session) + tkt.size;
3305       dbdata_tls_session * dt = store_get(dlen, TRUE);
3306
3307       DEBUG(D_tls) debug_printf("session data size %u\n", (unsigned)tkt.size);
3308       memcpy(dt->session, tkt.data, tkt.size);
3309       gnutls_free(tkt.data);
3310
3311       if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3312         {
3313         /* key for the db is the IP */
3314         dbfn_delete(dbm_file, host->address);
3315         dbfn_write(dbm_file, host->address, dt, dlen);
3316         dbfn_close(dbm_file);
3317
3318         DEBUG(D_tls)
3319           debug_printf("wrote session db (len %u)\n", (unsigned)dlen);
3320         }
3321       }
3322     else DEBUG(D_tls)
3323       debug_printf("extract session data: %s\n", US gnutls_strerror(rc));
3324   }
3325 }
3326
3327
3328 /* With a TLS1.3 session, the ticket(s) are not seen until
3329 the first data read is attempted.  And there's often two of them.
3330 Pick them up with this callback.  We are also called for 1.2
3331 but we do nothing.
3332 */
3333 static int
3334 tls_client_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
3335   unsigned incoming, const gnutls_datum_t * msg)
3336 {
3337 exim_gnutls_state_st * state = gnutls_session_get_ptr(sess);
3338 tls_support * tlsp = state->tlsp;
3339
3340 DEBUG(D_tls) debug_printf("newticket cb\n");
3341
3342 if (!tlsp->ticket_received)
3343   tls_save_session(tlsp, sess, state->host);
3344 return 0;
3345 }
3346
3347
3348 static void
3349 tls_client_resume_prehandshake(exim_gnutls_state_st * state,
3350   tls_support * tlsp, host_item * host,
3351   smtp_transport_options_block * ob)
3352 {
3353 gnutls_session_set_ptr(state->session, state);
3354 gnutls_handshake_set_hook_function(state->session,
3355   GNUTLS_HANDSHAKE_NEW_SESSION_TICKET, GNUTLS_HOOK_POST, tls_client_ticket_cb);
3356
3357 tls_retrieve_session(tlsp, state->session, host, ob);
3358 }
3359
3360 static void
3361 tls_client_resume_posthandshake(exim_gnutls_state_st * state,
3362   tls_support * tlsp, host_item * host)
3363 {
3364 if (gnutls_session_is_resumed(state->session))
3365   {
3366   DEBUG(D_tls) debug_printf("Session resumed\n");
3367   tlsp->resumption |= RESUME_USED;
3368   }
3369
3370 tls_save_session(tlsp, state->session, host);
3371 }
3372 #endif  /* !DISABLE_TLS_RESUME */
3373
3374
3375 /*************************************************
3376 *    Start a TLS session in a client             *
3377 *************************************************/
3378
3379 /* Called from the smtp transport after STARTTLS has been accepted.
3380
3381 Arguments:
3382   cctx          connection context
3383   conn_args     connection details
3384   cookie        datum for randomness (not used)
3385   tlsp          record details of channel configuration here; must be non-NULL
3386   errstr        error string pointer
3387
3388 Returns:        TRUE for success with TLS session context set in smtp context,
3389                 FALSE on error
3390 */
3391
3392 BOOL
3393 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3394   void * cookie ARG_UNUSED,
3395   tls_support * tlsp, uschar ** errstr)
3396 {
3397 host_item * host = conn_args->host;          /* for msgs and option-tests */
3398 transport_instance * tb = conn_args->tblock; /* always smtp or NULL */
3399 smtp_transport_options_block * ob = tb
3400   ? (smtp_transport_options_block *)tb->options_block
3401   : &smtp_transport_option_defaults;
3402 int rc;
3403 exim_gnutls_state_st * state = NULL;
3404 uschar * cipher_list = NULL;
3405
3406 #ifndef DISABLE_OCSP
3407 BOOL require_ocsp =
3408   verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3409 BOOL request_ocsp = require_ocsp ? TRUE
3410   : verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3411 #endif
3412
3413 DEBUG(D_tls) debug_printf("initialising GnuTLS as a client on fd %d\n", cctx->sock);
3414
3415 #ifdef SUPPORT_DANE
3416 /* If dane is flagged, have either request or require dane for this host, and
3417 a TLSA record found.  Therefore, dane verify required.  Which implies cert must
3418 be requested and supplied, dane verify must pass, and cert verify irrelevant
3419 (incl.  hostnames), and (caller handled) require_tls and sni=$domain */
3420
3421 if (conn_args->dane && ob->dane_require_tls_ciphers)
3422   {
3423   /* not using Expand_check_tlsvar because not yet in state */
3424   if (!expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3425       &cipher_list, errstr))
3426     return FALSE;
3427   cipher_list = cipher_list && *cipher_list
3428     ? ob->dane_require_tls_ciphers : ob->tls_require_ciphers;
3429   }
3430 #endif
3431
3432 if (!cipher_list)
3433   cipher_list = ob->tls_require_ciphers;
3434
3435   {
3436 #ifdef MEASURE_TIMING
3437   struct timeval t0;
3438   gettimeofday(&t0, NULL);
3439 #endif
3440
3441   if (tls_init(host, ob, cipher_list, &state, tlsp, errstr) != OK)
3442     return FALSE;
3443
3444 #ifdef MEASURE_TIMING
3445   report_time_since(&t0, US"client tls_init (delta)");
3446 #endif
3447   }
3448
3449 if (ob->tls_alpn)
3450 #ifdef EXIM_HAVE_ALPN
3451   {
3452   const gnutls_datum_t * plist;
3453   unsigned plen;
3454
3455   if (!tls_alpn_plist(ob->tls_alpn, &plist, &plen, errstr))
3456     return FALSE;
3457   if (plist)
3458     if (gnutls_alpn_set_protocols(state->session, plist, plen, 0) != 0)
3459       {
3460       tls_error(US"alpn init", NULL, state->host, errstr);
3461       return FALSE;
3462       }
3463     else
3464       DEBUG(D_tls) debug_printf("Setting TLS ALPN '%s'\n", ob->tls_alpn);
3465   }
3466 #else
3467   log_write(0, LOG_MAIN, "ALPN unusable with this GnuTLS library version; ignoring \"%s\"\n",
3468           ob->tls_alpn);
3469 #endif
3470
3471   {
3472   int dh_min_bits = ob->tls_dh_min_bits;
3473   if (dh_min_bits < EXIM_CLIENT_DH_MIN_MIN_BITS)
3474     {
3475     DEBUG(D_tls)
3476       debug_printf("WARNING: tls_dh_min_bits far too low,"
3477                     " clamping %d up to %d\n",
3478           dh_min_bits, EXIM_CLIENT_DH_MIN_MIN_BITS);
3479     dh_min_bits = EXIM_CLIENT_DH_MIN_MIN_BITS;
3480     }
3481
3482   DEBUG(D_tls) debug_printf("Setting D-H prime minimum"
3483                     " acceptable bits to %d\n",
3484       dh_min_bits);
3485   gnutls_dh_set_prime_bits(state->session, dh_min_bits);
3486   }
3487
3488 /* Stick to the old behaviour for compatibility if tls_verify_certificates is
3489 set but both tls_verify_hosts and tls_try_verify_hosts are unset. Check only
3490 the specified host patterns if one of them is defined */
3491
3492 #ifdef SUPPORT_DANE
3493 if (conn_args->dane && dane_tlsa_load(state, &conn_args->tlsa_dnsa))
3494   {
3495   DEBUG(D_tls)
3496     debug_printf("TLS: server certificate DANE required\n");
3497   state->verify_requirement = VERIFY_DANE;
3498   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
3499   }
3500 else
3501 #endif
3502     if (  (  state->exp_tls_verify_certificates
3503           && !ob->tls_verify_hosts
3504           && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
3505           )
3506         || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
3507        )
3508   {
3509   tls_client_setup_hostname_checks(host, state, ob);
3510   DEBUG(D_tls)
3511     debug_printf("TLS: server certificate verification required\n");
3512   state->verify_requirement = VERIFY_REQUIRED;
3513   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
3514   }
3515 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
3516   {
3517   tls_client_setup_hostname_checks(host, state, ob);
3518   DEBUG(D_tls)
3519     debug_printf("TLS: server certificate verification optional\n");
3520   state->verify_requirement = VERIFY_OPTIONAL;
3521   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
3522   }
3523 else
3524   {
3525   DEBUG(D_tls)
3526     debug_printf("TLS: server certificate verification not required\n");
3527   state->verify_requirement = VERIFY_NONE;
3528   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
3529   }
3530
3531 #ifndef DISABLE_OCSP
3532                         /* supported since GnuTLS 3.1.3 */
3533 if (request_ocsp)
3534   {
3535   DEBUG(D_tls) debug_printf("TLS: will request OCSP stapling\n");
3536   if ((rc = gnutls_ocsp_status_request_enable_client(state->session,
3537                     NULL, 0, NULL)) != OK)
3538     {
3539     tls_error_gnu(state, US"cert-status-req", rc, errstr);
3540     return FALSE;
3541     }
3542   tlsp->ocsp = OCSP_NOT_RESP;
3543   }
3544 #endif
3545
3546 #ifdef EXIM_HAVE_TLS_RESUME
3547 tls_client_resume_prehandshake(state, tlsp, host, ob);
3548 #endif
3549
3550 #ifndef DISABLE_EVENT
3551 if (tb && tb->event_action)
3552   {
3553   state->event_action = tb->event_action;
3554   gnutls_session_set_ptr(state->session, state);
3555   gnutls_certificate_set_verify_function(state->lib_state.x509_cred, verify_cb);
3556   }
3557 #endif
3558
3559 gnutls_transport_set_ptr(state->session, (gnutls_transport_ptr_t)(long) cctx->sock);
3560 state->fd_in = cctx->sock;
3561 state->fd_out = cctx->sock;
3562
3563 DEBUG(D_tls) debug_printf("about to gnutls_handshake\n");
3564 /* There doesn't seem to be a built-in timeout on connection. */
3565
3566 sigalrm_seen = FALSE;
3567 ALARM(ob->command_timeout);
3568 do
3569   rc = gnutls_handshake(state->session);
3570 while (rc == GNUTLS_E_AGAIN || rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen);
3571 ALARM_CLR(0);
3572
3573 if (rc != GNUTLS_E_SUCCESS)
3574   {
3575   if (sigalrm_seen)
3576     {
3577     gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_USER_CANCELED);
3578     tls_error(US"gnutls_handshake", US"timed out", state->host, errstr);
3579     }
3580   else
3581     tls_error_gnu(state, US"gnutls_handshake", rc, errstr);
3582   return FALSE;
3583   }
3584
3585 DEBUG(D_tls) post_handshake_debug(state);
3586
3587 /* Verify late */
3588
3589 if (!verify_certificate(state, errstr))
3590   {
3591   tls_error(US"certificate verification failed", *errstr, state->host, errstr);
3592   return FALSE;
3593   }
3594
3595 #ifdef GNUTLS_SFLAGS_EXT_MASTER_SECRET
3596 if (gnutls_session_get_flags(state->session) & GNUTLS_SFLAGS_EXT_MASTER_SECRET)
3597   tlsp->ext_master_secret = TRUE;
3598 #endif
3599
3600 #ifndef DISABLE_OCSP
3601 if (request_ocsp)
3602   {
3603   DEBUG(D_tls)
3604     {
3605     gnutls_datum_t stapling;
3606     gnutls_ocsp_resp_t resp;
3607     gnutls_datum_t printed;
3608     unsigned idx = 0;
3609
3610     for (;
3611 # ifdef GNUTLS_OCSP_STATUS_REQUEST_GET2
3612          (rc = gnutls_ocsp_status_request_get2(state->session, idx, &stapling)) == 0;
3613 #else
3614          (rc = gnutls_ocsp_status_request_get(state->session, &stapling)) == 0;
3615 #endif
3616          idx++)
3617       if (  (rc= gnutls_ocsp_resp_init(&resp)) == 0
3618          && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
3619          && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_COMPACT, &printed)) == 0
3620          )
3621         {
3622         debug_printf("%.4096s", printed.data);
3623         gnutls_free(printed.data);
3624         }
3625       else
3626         (void) tls_error_gnu(state, US"ocsp decode", rc, errstr);
3627     if (idx == 0 && rc)
3628       (void) tls_error_gnu(state, US"ocsp decode", rc, errstr);
3629     }
3630
3631   if (gnutls_ocsp_status_request_is_checked(state->session, 0) == 0)
3632     {
3633     tlsp->ocsp = OCSP_FAILED;
3634     tls_error(US"certificate status check failed", NULL, state->host, errstr);
3635     if (require_ocsp)
3636       return FALSE;
3637     }
3638   else
3639     {
3640     DEBUG(D_tls) debug_printf("Passed OCSP checking\n");
3641     tlsp->ocsp = OCSP_VFIED;
3642     }
3643   }
3644 #endif
3645
3646 #ifdef EXIM_HAVE_TLS_RESUME
3647 tls_client_resume_posthandshake(state, tlsp, host);
3648 #endif
3649
3650 #ifdef EXIM_HAVE_ALPN
3651 if (ob->tls_alpn)       /* We requested. See what was negotiated. */
3652   {
3653   gnutls_datum_t p = {.size = 0};
3654
3655   if (gnutls_alpn_get_selected_protocol(state->session, &p) == 0)
3656     { DEBUG(D_tls) debug_printf("ALPN negotiated: '%.*s'\n", (int)p.size, p.data); }
3657   else if (verify_check_given_host(CUSS &ob->hosts_require_alpn, host) == OK)
3658     {
3659     gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_NO_APPLICATION_PROTOCOL);
3660     tls_error(US"handshake", US"ALPN required but not negotiated", state->host, errstr);
3661     return FALSE;
3662     }
3663   else
3664     DEBUG(D_tls) debug_printf("No ALPN negotiated");
3665   }
3666 #endif
3667
3668 /* Sets various Exim expansion variables; may need to adjust for ACL callouts */
3669
3670 extract_exim_vars_from_tls_state(state);
3671
3672 cctx->tls_ctx = state;
3673 return TRUE;
3674 }
3675
3676
3677
3678
3679 /*
3680 Arguments:
3681   ct_ctx        client TLS context pointer, or NULL for the one global server context
3682 */
3683
3684 void
3685 tls_shutdown_wr(void * ct_ctx)
3686 {
3687 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3688 tls_support * tlsp = state->tlsp;
3689
3690 if (!tlsp || tlsp->active.sock < 0) return;  /* TLS was not active */
3691
3692 tls_write(ct_ctx, NULL, 0, FALSE);      /* flush write buffer */
3693
3694 HDEBUG(D_transport|D_tls|D_acl|D_v) debug_printf_indent("  SMTP(TLS shutdown)>>\n");
3695 gnutls_bye(state->session, GNUTLS_SHUT_WR);
3696 }
3697
3698 /*************************************************
3699 *         Close down a TLS session               *
3700 *************************************************/
3701
3702 /* This is also called from within a delivery subprocess forked from the
3703 daemon, to shut down the TLS library, without actually doing a shutdown (which
3704 would tamper with the TLS session in the parent process).
3705
3706 Arguments:
3707   ct_ctx        client context pointer, or NULL for the one global server context
3708   do_shutdown   0 no data-flush or TLS close-alert
3709                 1 if TLS close-alert is to be sent,
3710                 2 if also response to be waited for (2s timeout)
3711
3712 Returns:     nothing
3713 */
3714
3715 void
3716 tls_close(void * ct_ctx, int do_shutdown)
3717 {
3718 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3719 tls_support * tlsp = state->tlsp;
3720
3721 if (!tlsp || tlsp->active.sock < 0) return;  /* TLS was not active */
3722
3723 if (do_shutdown)
3724   {
3725   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3726     do_shutdown > 1 ? " (with response-wait)" : "");
3727
3728   tls_write(ct_ctx, NULL, 0, FALSE);    /* flush write buffer */
3729
3730   ALARM(2);
3731   gnutls_bye(state->session, do_shutdown > 1 ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
3732   ALARM_CLR(0);
3733   }
3734
3735 if (!ct_ctx)    /* server */
3736   {
3737   receive_getc =        smtp_getc;
3738   receive_getbuf =      smtp_getbuf;
3739   receive_get_cache =   smtp_get_cache;
3740   receive_hasc =        smtp_hasc;
3741   receive_ungetc =      smtp_ungetc;
3742   receive_feof =        smtp_feof;
3743   receive_ferror =      smtp_ferror;
3744   receive_smtp_buffered = smtp_buffered;
3745   }
3746
3747 gnutls_deinit(state->session);
3748 gnutls_certificate_free_credentials(state->lib_state.x509_cred);
3749 state->lib_state = null_tls_preload;
3750
3751 tlsp->active.sock = -1;
3752 tlsp->active.tls_ctx = NULL;
3753 /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
3754 tlsp->channelbinding = NULL;
3755
3756
3757 if (state->xfer_buffer) store_free(state->xfer_buffer);
3758 }
3759
3760
3761
3762
3763 static BOOL
3764 tls_refill(unsigned lim)
3765 {
3766 exim_gnutls_state_st * state = &state_server;
3767 ssize_t inbytes;
3768
3769 DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(session=%p, buffer=%p, buffersize=%u)\n",
3770   state->session, state->xfer_buffer, ssl_xfer_buffer_size);
3771
3772 sigalrm_seen = FALSE;
3773 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3774
3775 errno = 0;
3776 do
3777   inbytes = gnutls_record_recv(state->session, state->xfer_buffer,
3778     MIN(ssl_xfer_buffer_size, lim));
3779 while (inbytes == GNUTLS_E_AGAIN);
3780
3781 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3782
3783 if (had_command_timeout)                /* set by signal handler */
3784   smtp_command_timeout_exit();          /* does not return */
3785 if (had_command_sigterm)
3786   smtp_command_sigterm_exit();
3787 if (had_data_timeout)
3788   smtp_data_timeout_exit();
3789 if (had_data_sigint)
3790   smtp_data_sigint_exit();
3791
3792 /* Timeouts do not get this far.  A zero-byte return appears to mean that the
3793 TLS session has been closed down, not that the socket itself has been closed
3794 down. Revert to non-TLS handling. */
3795
3796 if (sigalrm_seen)
3797   {
3798   DEBUG(D_tls) debug_printf("Got tls read timeout\n");
3799   state->xfer_error = TRUE;
3800   return FALSE;
3801   }
3802
3803 else if (inbytes == 0)
3804   {
3805   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
3806   tls_close(NULL, TLS_NO_SHUTDOWN);
3807   return FALSE;
3808   }
3809
3810 /* Handle genuine errors */
3811
3812 else if (inbytes < 0)
3813   {
3814   DEBUG(D_tls) debug_printf("%s: err from gnutls_record_recv\n", __FUNCTION__);
3815   record_io_error(state, (int) inbytes, US"recv", NULL);
3816   state->xfer_error = TRUE;
3817   return FALSE;
3818   }
3819 #ifndef DISABLE_DKIM
3820 dkim_exim_verify_feed(state->xfer_buffer, inbytes);
3821 #endif
3822 state->xfer_buffer_hwm = (int) inbytes;
3823 state->xfer_buffer_lwm = 0;
3824 return TRUE;
3825 }
3826
3827 /*************************************************
3828 *            TLS version of getc                 *
3829 *************************************************/
3830
3831 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3832 it refills the buffer via the GnuTLS reading function.
3833 Only used by the server-side TLS.
3834
3835 This feeds DKIM and should be used for all message-body reads.
3836
3837 Arguments:  lim         Maximum amount to read/buffer
3838 Returns:    the next character or EOF
3839 */
3840
3841 int
3842 tls_getc(unsigned lim)
3843 {
3844 exim_gnutls_state_st * state = &state_server;
3845
3846 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
3847   if (!tls_refill(lim))
3848     return state->xfer_error ? EOF : smtp_getc(lim);
3849
3850 /* Something in the buffer; return next uschar */
3851
3852 return state->xfer_buffer[state->xfer_buffer_lwm++];
3853 }
3854
3855 BOOL
3856 tls_hasc(void)
3857 {
3858 exim_gnutls_state_st * state = &state_server;
3859 return state->xfer_buffer_lwm < state->xfer_buffer_hwm;
3860 }
3861
3862 uschar *
3863 tls_getbuf(unsigned * len)
3864 {
3865 exim_gnutls_state_st * state = &state_server;
3866 unsigned size;
3867 uschar * buf;
3868
3869 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
3870   if (!tls_refill(*len))
3871     {
3872     if (!state->xfer_error) return smtp_getbuf(len);
3873     *len = 0;
3874     return NULL;
3875     }
3876
3877 if ((size = state->xfer_buffer_hwm - state->xfer_buffer_lwm) > *len)
3878   size = *len;
3879 buf = &state->xfer_buffer[state->xfer_buffer_lwm];
3880 state->xfer_buffer_lwm += size;
3881 *len = size;
3882 return buf;
3883 }
3884
3885
3886 /* Get up to the given number of bytes from any cached data, and feed to dkim. */
3887 void
3888 tls_get_cache(unsigned lim)
3889 {
3890 #ifndef DISABLE_DKIM
3891 exim_gnutls_state_st * state = &state_server;
3892 int n = state->xfer_buffer_hwm - state->xfer_buffer_lwm;
3893 if (n > lim)
3894   n = lim;
3895 if (n > 0)
3896   dkim_exim_verify_feed(state->xfer_buffer+state->xfer_buffer_lwm, n);
3897 #endif
3898 }
3899
3900
3901 BOOL
3902 tls_could_read(void)
3903 {
3904 return state_server.xfer_buffer_lwm < state_server.xfer_buffer_hwm
3905  || gnutls_record_check_pending(state_server.session) > 0;
3906 }
3907
3908
3909 /*************************************************
3910 *          Read bytes from TLS channel           *
3911 *************************************************/
3912
3913 /* This does not feed DKIM, so if the caller uses this for reading message body,
3914 then the caller must feed DKIM.
3915
3916 Arguments:
3917   ct_ctx    client context pointer, or NULL for the one global server context
3918   buff      buffer of data
3919   len       size of buffer
3920
3921 Returns:    the number of bytes read
3922             -1 after a failed read, including EOF
3923 */
3924
3925 int
3926 tls_read(void * ct_ctx, uschar *buff, size_t len)
3927 {
3928 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3929 ssize_t inbytes;
3930
3931 if (len > INT_MAX)
3932   len = INT_MAX;
3933
3934 if (state->xfer_buffer_lwm < state->xfer_buffer_hwm)
3935   DEBUG(D_tls)
3936     debug_printf("*** PROBABLY A BUG *** " \
3937         "tls_read() called with data in the tls_getc() buffer, %d ignored\n",
3938         state->xfer_buffer_hwm - state->xfer_buffer_lwm);
3939
3940 DEBUG(D_tls)
3941   debug_printf("Calling gnutls_record_recv(session=%p, buffer=%p, len=" SIZE_T_FMT ")\n",
3942       state->session, buff, len);
3943
3944 errno = 0;
3945 do
3946   inbytes = gnutls_record_recv(state->session, buff, len);
3947 while (inbytes == GNUTLS_E_AGAIN);
3948
3949 if (inbytes > 0) return inbytes;
3950 if (inbytes == 0)
3951   {
3952   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
3953   }
3954 else
3955   {
3956   DEBUG(D_tls) debug_printf("%s: err from gnutls_record_recv\n", __FUNCTION__);
3957   record_io_error(state, (int)inbytes, US"recv", NULL);
3958   }
3959
3960 return -1;
3961 }
3962
3963
3964
3965
3966 /*************************************************
3967 *         Write bytes down TLS channel           *
3968 *************************************************/
3969
3970 /*
3971 Arguments:
3972   ct_ctx    client context pointer, or NULL for the one global server context
3973   buff      buffer of data
3974   len       number of bytes
3975   more      more data expected soon
3976
3977 Calling with len zero and more unset will flush buffered writes.  The buff
3978 argument can be null for that case.
3979
3980 Returns:    the number of bytes after a successful write,
3981             -1 after a failed write
3982 */
3983
3984 int
3985 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
3986 {
3987 ssize_t outbytes;
3988 size_t left = len;
3989 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3990
3991 #ifdef SUPPORT_CORK
3992 if (more && !state->corked)
3993   {
3994   DEBUG(D_tls) debug_printf("gnutls_record_cork(session=%p)\n", state->session);
3995   gnutls_record_cork(state->session);
3996   state->corked = TRUE;
3997   }
3998 #endif
3999
4000 DEBUG(D_tls) debug_printf("%s(%p, " SIZE_T_FMT "%s)\n", __FUNCTION__,
4001   buff, left, more ? ", more" : "");
4002
4003 while (left > 0)
4004   {
4005   DEBUG(D_tls) debug_printf("gnutls_record_send(session=%p, buffer=%p, left=" SIZE_T_FMT ")\n",
4006       state->session, buff, left);
4007
4008   errno = 0;
4009   do
4010     outbytes = gnutls_record_send(state->session, buff, left);
4011   while (outbytes == GNUTLS_E_AGAIN);
4012
4013   DEBUG(D_tls) debug_printf("outbytes=" SSIZE_T_FMT "\n", outbytes);
4014
4015   if (outbytes < 0)
4016     {
4017 #ifdef GNUTLS_E_PREMATURE_TERMINATION
4018     if (  outbytes == GNUTLS_E_PREMATURE_TERMINATION && errno == ECONNRESET
4019        && !ct_ctx && f.smtp_in_quit
4020        )
4021       {                                 /* Outlook, dammit */
4022       if (LOGGING(protocol_detail))
4023         log_write(0, LOG_MAIN, "[%s] after QUIT, client reset TCP before"
4024           " SMTP response and TLS close\n", sender_host_address);
4025       else
4026         DEBUG(D_tls) debug_printf("[%s] SSL_write: after QUIT,"
4027           " client reset TCP before TLS close\n", sender_host_address);
4028       }
4029     else
4030 #endif
4031       {
4032       DEBUG(D_tls) debug_printf("%s: gnutls_record_send err\n", __FUNCTION__);
4033       record_io_error(state, outbytes, US"send", NULL);
4034       }
4035     return -1;
4036     }
4037   if (outbytes == 0)
4038     {
4039     record_io_error(state, 0, US"send", US"TLS channel closed on write");
4040     return -1;
4041     }
4042
4043   left -= outbytes;
4044   buff += outbytes;
4045   }
4046
4047 if (len > INT_MAX)
4048   {
4049   DEBUG(D_tls)
4050     debug_printf("Whoops!  Wrote more bytes (" SIZE_T_FMT ") than INT_MAX\n",
4051         len);
4052   len = INT_MAX;
4053   }
4054
4055 #ifdef SUPPORT_CORK
4056 if (!more && state->corked)
4057   {
4058   DEBUG(D_tls) debug_printf("gnutls_record_uncork(session=%p)\n", state->session);
4059   do
4060     /* We can't use GNUTLS_RECORD_WAIT here, as it retries on
4061     GNUTLS_E_AGAIN || GNUTLS_E_INTR, which would break our timeout set by alarm().
4062     The GNUTLS_E_AGAIN should not happen ever, as our sockets are blocking anyway.
4063     But who knows. (That all relies on the fact that GNUTLS_E_INTR and GNUTLS_E_AGAIN
4064     match the EINTR and EAGAIN errno values.) */
4065     outbytes = gnutls_record_uncork(state->session, 0);
4066   while (outbytes == GNUTLS_E_AGAIN);
4067
4068   if (outbytes < 0)
4069     {
4070     record_io_error(state, len, US"uncork", NULL);
4071     return -1;
4072     }
4073
4074   state->corked = FALSE;
4075   }
4076 #endif
4077
4078 return (int) len;
4079 }
4080
4081
4082
4083
4084 /*************************************************
4085 *            Random number generation            *
4086 *************************************************/
4087
4088 /* Pseudo-random number generation.  The result is not expected to be
4089 cryptographically strong but not so weak that someone will shoot themselves
4090 in the foot using it as a nonce in input in some email header scheme or
4091 whatever weirdness they'll twist this into.  The result should handle fork()
4092 and avoid repeating sequences.  OpenSSL handles that for us.
4093
4094 Arguments:
4095   max       range maximum
4096 Returns     a random number in range [0, max-1]
4097 */
4098
4099 #ifdef HAVE_GNUTLS_RND
4100 int
4101 vaguely_random_number(int max)
4102 {
4103 unsigned int r;
4104 int i, needed_len;
4105 uschar smallbuf[sizeof(r)];
4106
4107 if (max <= 1)
4108   return 0;
4109
4110 needed_len = sizeof(r);
4111 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
4112 asked for a number less than 10. */
4113
4114 for (r = max, i = 0; r; ++i)
4115   r >>= 1;
4116 i = (i + 7) / 8;
4117 if (i < needed_len)
4118   needed_len = i;
4119
4120 i = gnutls_rnd(GNUTLS_RND_NONCE, smallbuf, needed_len);
4121 if (i < 0)
4122   {
4123   DEBUG(D_all) debug_printf("gnutls_rnd() failed, using fallback\n");
4124   return vaguely_random_number_fallback(max);
4125   }
4126 r = 0;
4127 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
4128   r = r * 256 + *p;
4129
4130 /* We don't particularly care about weighted results; if someone wants
4131  * smooth distribution and cares enough then they should submit a patch then. */
4132 return r % max;
4133 }
4134 #else /* HAVE_GNUTLS_RND */
4135 int
4136 vaguely_random_number(int max)
4137 {
4138   return vaguely_random_number_fallback(max);
4139 }
4140 #endif /* HAVE_GNUTLS_RND */
4141
4142
4143
4144
4145 /*************************************************
4146 *  Let tls_require_ciphers be checked at startup *
4147 *************************************************/
4148
4149 /* The tls_require_ciphers option, if set, must be something which the
4150 library can parse.
4151
4152 Returns:     NULL on success, or error message
4153 */
4154
4155 uschar *
4156 tls_validate_require_cipher(void)
4157 {
4158 int rc;
4159 uschar *expciphers = NULL;
4160 gnutls_priority_t priority_cache;
4161 const char *errpos;
4162 uschar * dummy_errstr;
4163
4164 #ifdef GNUTLS_AUTO_GLOBAL_INIT
4165 # define validate_check_rc(Label) do { \
4166   if (rc != GNUTLS_E_SUCCESS) { if (exim_gnutls_base_init_done) \
4167     return string_sprintf("%s failed: %s", (Label), gnutls_strerror(rc)); } } while (0)
4168 # define return_deinit(Label) do { return (Label); } while (0)
4169 #else
4170 # define validate_check_rc(Label) do { \
4171   if (rc != GNUTLS_E_SUCCESS) { if (exim_gnutls_base_init_done) gnutls_global_deinit(); \
4172     return string_sprintf("%s failed: %s", (Label), gnutls_strerror(rc)); } } while (0)
4173 # define return_deinit(Label) do { gnutls_global_deinit(); return (Label); } while (0)
4174 #endif
4175
4176 if (exim_gnutls_base_init_done)
4177   log_write(0, LOG_MAIN|LOG_PANIC,
4178       "already initialised GnuTLS, Exim developer bug");
4179
4180 #if defined(HAVE_GNUTLS_PKCS11) && !defined(GNUTLS_AUTO_PKCS11_MANUAL)
4181 if (!gnutls_allow_auto_pkcs11)
4182   {
4183   rc = gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_MANUAL, NULL);
4184   validate_check_rc(US"gnutls_pkcs11_init");
4185   }
4186 #endif
4187 #ifndef GNUTLS_AUTO_GLOBAL_INIT
4188 rc = gnutls_global_init();
4189 validate_check_rc(US"gnutls_global_init()");
4190 #endif
4191 exim_gnutls_base_init_done = TRUE;
4192
4193 if (!(tls_require_ciphers && *tls_require_ciphers))
4194   return_deinit(NULL);
4195
4196 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
4197                   &dummy_errstr))
4198   return_deinit(US"failed to expand tls_require_ciphers");
4199
4200 if (!(expciphers && *expciphers))
4201   return_deinit(NULL);
4202
4203 DEBUG(D_tls)
4204   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
4205
4206 rc = gnutls_priority_init(&priority_cache, CS expciphers, &errpos);
4207 validate_check_rc(string_sprintf(
4208       "gnutls_priority_init(%s) failed at offset %ld, \"%.8s..\"",
4209       expciphers, (long)(errpos - CS expciphers), errpos));
4210
4211 #undef return_deinit
4212 #undef validate_check_rc
4213 #ifndef GNUTLS_AUTO_GLOBAL_INIT
4214 gnutls_global_deinit();
4215 #endif
4216
4217 return NULL;
4218 }
4219
4220
4221
4222
4223 /*************************************************
4224 *         Report the library versions.           *
4225 *************************************************/
4226
4227 /* See a description in tls-openssl.c for an explanation of why this exists.
4228
4229 Arguments:   a FILE* to print the results to
4230 Returns:     nothing
4231 */
4232
4233 void
4234 tls_version_report(FILE *f)
4235 {
4236 fprintf(f, "Library version: GnuTLS: Compile: %s\n"
4237            "                         Runtime: %s\n",
4238            LIBGNUTLS_VERSION,
4239            gnutls_check_version(NULL));
4240 }
4241
4242 #endif  /*!MACRO_PREDEF*/
4243 /* vi: aw ai sw=2
4244 */
4245 /* End of tls-gnu.c */