ca60ddb6abdd509d3e82d3be4bc1d32b18bdaf7d
[users/jgh/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 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Copyright (c) Phil Pennock 2012 */
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 >= 0x030306
57 # define SUPPORT_CA_DIR
58 #else
59 # undef  SUPPORT_CA_DIR
60 #endif
61 #if GNUTLS_VERSION_NUMBER >= 0x030014
62 # define SUPPORT_SYSDEFAULT_CABUNDLE
63 #endif
64 #if GNUTLS_VERSION_NUMBER >= 0x030104
65 # define GNUTLS_CERT_VFY_STATUS_PRINT
66 #endif
67 #if GNUTLS_VERSION_NUMBER >= 0x030109
68 # define SUPPORT_CORK
69 #endif
70 #if GNUTLS_VERSION_NUMBER >= 0x03010a
71 # define SUPPORT_GNUTLS_SESS_DESC
72 #endif
73 #if GNUTLS_VERSION_NUMBER >= 0x030500
74 # define SUPPORT_GNUTLS_KEYLOG
75 #endif
76 #if GNUTLS_VERSION_NUMBER >= 0x030506 && !defined(DISABLE_OCSP)
77 # define SUPPORT_SRV_OCSP_STACK
78 #endif
79
80 #ifdef SUPPORT_DANE
81 # if GNUTLS_VERSION_NUMBER >= 0x030000
82 #  define DANESSL_USAGE_DANE_TA 2
83 #  define DANESSL_USAGE_DANE_EE 3
84 # else
85 #  error GnuTLS version too early for DANE
86 # endif
87 # if GNUTLS_VERSION_NUMBER < 0x999999
88 #  define GNUTLS_BROKEN_DANE_VALIDATION
89 # endif
90 #endif
91
92 #ifdef EXPERIMENTAL_TLS_RESUME
93 # if GNUTLS_VERSION_NUMBER < 0x030603
94 #  error GNUTLS version too early for session-resumption
95 # endif
96 #endif
97
98 #ifndef DISABLE_OCSP
99 # include <gnutls/ocsp.h>
100 #endif
101 #ifdef SUPPORT_DANE
102 # include <gnutls/dane.h>
103 #endif
104
105 #include "tls-cipher-stdname.c"
106
107
108 #ifdef MACRO_PREDEF
109 void
110 options_tls(void)
111 {
112 # ifdef EXPERIMENTAL_TLS_RESUME
113 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
114 # endif
115 }
116 #else
117
118
119 /* GnuTLS 2 vs 3
120
121 GnuTLS 3 only:
122   gnutls_global_set_audit_log_function()
123
124 Changes:
125   gnutls_certificate_verify_peers2(): is new, drop the 2 for old version
126 */
127
128 /* Local static variables for GnuTLS */
129
130 /* Values for verify_requirement */
131
132 enum peer_verify_requirement
133   { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED, VERIFY_DANE };
134
135 /* This holds most state for server or client; with this, we can set up an
136 outbound TLS-enabled connection in an ACL callout, while not stomping all
137 over the TLS variables available for expansion.
138
139 Some of these correspond to variables in globals.c; those variables will
140 be set to point to content in one of these instances, as appropriate for
141 the stage of the process lifetime.
142
143 Not handled here: global tls_channelbinding_b64.
144 */
145
146 typedef struct exim_gnutls_state {
147   gnutls_session_t      session;
148   gnutls_certificate_credentials_t x509_cred;
149   gnutls_priority_t     priority_cache;
150   enum peer_verify_requirement verify_requirement;
151   int                   fd_in;
152   int                   fd_out;
153   BOOL                  peer_cert_verified;
154   BOOL                  peer_dane_verified;
155   BOOL                  trigger_sni_changes;
156   BOOL                  have_set_peerdn;
157   const struct host_item *host;         /* NULL if server */
158   gnutls_x509_crt_t     peercert;
159   uschar                *peerdn;
160   uschar                *ciphersuite;
161   uschar                *received_sni;
162
163   const uschar *tls_certificate;
164   const uschar *tls_privatekey;
165   const uschar *tls_sni; /* client send only, not received */
166   const uschar *tls_verify_certificates;
167   const uschar *tls_crl;
168   const uschar *tls_require_ciphers;
169
170   uschar *exp_tls_certificate;
171   uschar *exp_tls_privatekey;
172   uschar *exp_tls_verify_certificates;
173   uschar *exp_tls_crl;
174   uschar *exp_tls_require_ciphers;
175   const uschar *exp_tls_verify_cert_hostnames;
176 #ifndef DISABLE_EVENT
177   uschar *event_action;
178 #endif
179 #ifdef SUPPORT_DANE
180   char * const *        dane_data;
181   const int *           dane_data_len;
182 #endif
183
184   tls_support *tlsp;    /* set in tls_init() */
185
186   uschar *xfer_buffer;
187   int xfer_buffer_lwm;
188   int xfer_buffer_hwm;
189   BOOL xfer_eof;        /*XXX never gets set! */
190   BOOL xfer_error;
191 } exim_gnutls_state_st;
192
193 static const exim_gnutls_state_st exim_gnutls_state_init = {
194   /* all elements not explicitly intialised here get 0/NULL/FALSE */
195   .fd_in =              -1,
196   .fd_out =             -1,
197 };
198
199 /* Not only do we have our own APIs which don't pass around state, assuming
200 it's held in globals, GnuTLS doesn't appear to let us register callback data
201 for callbacks, or as part of the session, so we have to keep a "this is the
202 context we're currently dealing with" pointer and rely upon being
203 single-threaded to keep from processing data on an inbound TLS connection while
204 talking to another TLS connection for an outbound check.  This does mean that
205 there's no way for heart-beats to be responded to, for the duration of the
206 second connection.
207 XXX But see gnutls_session_get_ptr()
208 */
209
210 static exim_gnutls_state_st state_server;
211
212 /* dh_params are initialised once within the lifetime of a process using TLS;
213 if we used TLS in a long-lived daemon, we'd have to reconsider this.  But we
214 don't want to repeat this. */
215
216 static gnutls_dh_params_t dh_server_params = NULL;
217
218 static int ssl_session_timeout = 7200;  /* Two hours */
219
220 static const uschar * const exim_default_gnutls_priority = US"NORMAL";
221
222 /* Guard library core initialisation */
223
224 static BOOL exim_gnutls_base_init_done = FALSE;
225
226 #ifndef DISABLE_OCSP
227 static BOOL gnutls_buggy_ocsp = FALSE;
228 #endif
229
230 #ifdef EXPERIMENTAL_TLS_RESUME
231 static gnutls_datum_t server_sessticket_key;
232 #endif
233
234 /* ------------------------------------------------------------------------ */
235 /* macros */
236
237 #define MAX_HOST_LEN 255
238
239 /* Set this to control gnutls_global_set_log_level(); values 0 to 9 will setup
240 the library logging; a value less than 0 disables the calls to set up logging
241 callbacks.  GNuTLS also looks for an environment variable - except not for
242 setuid binaries, making it useless - "GNUTLS_DEBUG_LEVEL".
243 Allegedly the testscript line "GNUTLS_DEBUG_LEVEL=9 sudo exim ..." would work,
244 but the env var must be added to /etc/sudoers too. */
245 #ifndef EXIM_GNUTLS_LIBRARY_LOG_LEVEL
246 # define EXIM_GNUTLS_LIBRARY_LOG_LEVEL -1
247 #endif
248
249 #ifndef EXIM_CLIENT_DH_MIN_BITS
250 # define EXIM_CLIENT_DH_MIN_BITS 1024
251 #endif
252
253 /* With GnuTLS 2.12.x+ we have gnutls_sec_param_to_pk_bits() with which we
254 can ask for a bit-strength.  Without that, we stick to the constant we had
255 before, for now. */
256 #ifndef EXIM_SERVER_DH_BITS_PRE2_12
257 # define EXIM_SERVER_DH_BITS_PRE2_12 1024
258 #endif
259
260 #define expand_check_tlsvar(Varname, errstr) \
261   expand_check(state->Varname, US #Varname, &state->exp_##Varname, errstr)
262
263 #if GNUTLS_VERSION_NUMBER >= 0x020c00
264 # define HAVE_GNUTLS_SESSION_CHANNEL_BINDING
265 # define HAVE_GNUTLS_SEC_PARAM_CONSTANTS
266 # define HAVE_GNUTLS_RND
267 /* The security fix we provide with the gnutls_allow_auto_pkcs11 option
268  * (4.82 PP/09) introduces a compatibility regression. The symbol simply
269  * isn't available sometimes, so this needs to become a conditional
270  * compilation; the sanest way to deal with this being a problem on
271  * older OSes is to block it in the Local/Makefile with this compiler
272  * definition  */
273 # ifndef AVOID_GNUTLS_PKCS11
274 #  define HAVE_GNUTLS_PKCS11
275 # endif /* AVOID_GNUTLS_PKCS11 */
276 #endif
277
278
279
280
281 /* ------------------------------------------------------------------------ */
282 /* Callback declarations */
283
284 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
285 static void exim_gnutls_logger_cb(int level, const char *message);
286 #endif
287
288 static int exim_sni_handling_cb(gnutls_session_t session);
289
290 #ifndef DISABLE_OCSP
291 static int server_ocsp_stapling_cb(gnutls_session_t session, void * ptr,
292   gnutls_datum_t * ocsp_response);
293 #endif
294
295
296
297 /* Daemon one-time initialisation */
298 void
299 tls_daemon_init(void)
300 {
301 #ifdef EXPERIMENTAL_TLS_RESUME
302 /* We are dependent on the GnuTLS implementation of the Session Ticket
303 encryption; both the strength and the key rotation period.  We hope that
304 the strength at least matches that of the ciphersuite (but GnuTLS does not
305 document this). */
306
307 static BOOL once = FALSE;
308 if (once) return;
309 once = TRUE;
310 gnutls_session_ticket_key_generate(&server_sessticket_key);     /* >= 2.10.0 */
311 if (f.running_in_test_harness) ssl_session_timeout = 6;
312 #endif
313 }
314
315 /* ------------------------------------------------------------------------ */
316 /* Static functions */
317
318 /*************************************************
319 *               Handle TLS error                 *
320 *************************************************/
321
322 /* Called from lots of places when errors occur before actually starting to do
323 the TLS handshake, that is, while the session is still in clear. Always returns
324 DEFER for a server and FAIL for a client so that most calls can use "return
325 tls_error(...)" to do this processing and then give an appropriate return. A
326 single function is used for both server and client, because it is called from
327 some shared functions.
328
329 Argument:
330   prefix    text to include in the logged error
331   msg       additional error string (may be NULL)
332             usually obtained from gnutls_strerror()
333   host      NULL if setting up a server;
334             the connected host if setting up a client
335   errstr    pointer to returned error string
336
337 Returns:    OK/DEFER/FAIL
338 */
339
340 static int
341 tls_error(const uschar *prefix, const uschar *msg, const host_item *host,
342   uschar ** errstr)
343 {
344 if (errstr)
345   *errstr = string_sprintf("(%s)%s%s", prefix, msg ? ": " : "", msg ? msg : US"");
346 return host ? FAIL : DEFER;
347 }
348
349
350 static int
351 tls_error_gnu(const uschar *prefix, int err, const host_item *host,
352   uschar ** errstr)
353 {
354 return tls_error(prefix, US gnutls_strerror(err), host, errstr);
355 }
356
357 static int
358 tls_error_sys(const uschar *prefix, int err, const host_item *host,
359   uschar ** errstr)
360 {
361 return tls_error(prefix, US strerror(err), host, errstr);
362 }
363
364
365 /*************************************************
366 *    Deal with logging errors during I/O         *
367 *************************************************/
368
369 /* We have to get the identity of the peer from saved data.
370
371 Argument:
372   state    the current GnuTLS exim state container
373   rc       the GnuTLS error code, or 0 if it's a local error
374   when     text identifying read or write
375   text     local error text when rc is 0
376
377 Returns:   nothing
378 */
379
380 static void
381 record_io_error(exim_gnutls_state_st *state, int rc, uschar *when, uschar *text)
382 {
383 const uschar * msg;
384 uschar * errstr;
385
386 if (rc == GNUTLS_E_FATAL_ALERT_RECEIVED)
387   msg = string_sprintf("A TLS fatal alert has been received: %s",
388     US gnutls_alert_get_name(gnutls_alert_get(state->session)));
389 else
390   msg = US gnutls_strerror(rc);
391
392 (void) tls_error(when, msg, state->host, &errstr);
393
394 if (state->host)
395   log_write(0, LOG_MAIN, "H=%s [%s] TLS error on connection %s",
396     state->host->name, state->host->address, errstr);
397 else
398   {
399   uschar * conn_info = smtp_get_connection_info();
400   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0) conn_info += 5;
401   /* I'd like to get separated H= here, but too hard for now */
402   log_write(0, LOG_MAIN, "TLS error on %s %s", conn_info, errstr);
403   }
404 }
405
406
407
408
409 /*************************************************
410 *        Set various Exim expansion vars         *
411 *************************************************/
412
413 #define exim_gnutls_cert_err(Label) \
414   do \
415     { \
416     if (rc != GNUTLS_E_SUCCESS) \
417       { \
418       DEBUG(D_tls) debug_printf("TLS: cert problem: %s: %s\n", \
419         (Label), gnutls_strerror(rc)); \
420       return rc; \
421       } \
422     } while (0)
423
424 static int
425 import_cert(const gnutls_datum_t * cert, gnutls_x509_crt_t * crtp)
426 {
427 int rc;
428
429 rc = gnutls_x509_crt_init(crtp);
430 exim_gnutls_cert_err(US"gnutls_x509_crt_init (crt)");
431
432 rc = gnutls_x509_crt_import(*crtp, cert, GNUTLS_X509_FMT_DER);
433 exim_gnutls_cert_err(US"failed to import certificate [gnutls_x509_crt_import(cert)]");
434
435 return rc;
436 }
437
438 #undef exim_gnutls_cert_err
439
440
441 /* We set various Exim global variables from the state, once a session has
442 been established.  With TLS callouts, may need to change this to stack
443 variables, or just re-call it with the server state after client callout
444 has finished.
445
446 Make sure anything set here is unset in tls_getc().
447
448 Sets:
449   tls_active                fd
450   tls_bits                  strength indicator
451   tls_certificate_verified  bool indicator
452   tls_channelbinding_b64    for some SASL mechanisms
453   tls_cipher                a string
454   tls_peercert              pointer to library internal
455   tls_peerdn                a string
456   tls_sni                   a (UTF-8) string
457   tls_ourcert               pointer to library internal
458
459 Argument:
460   state      the relevant exim_gnutls_state_st *
461 */
462
463 static void
464 extract_exim_vars_from_tls_state(exim_gnutls_state_st * state)
465 {
466 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
467 int old_pool;
468 int rc;
469 gnutls_datum_t channel;
470 #endif
471 tls_support * tlsp = state->tlsp;
472
473 tlsp->active.sock = state->fd_out;
474 tlsp->active.tls_ctx = state;
475
476 DEBUG(D_tls) debug_printf("cipher: %s\n", state->ciphersuite);
477
478 tlsp->certificate_verified = state->peer_cert_verified;
479 #ifdef SUPPORT_DANE
480 tlsp->dane_verified = state->peer_dane_verified;
481 #endif
482
483 /* note that tls_channelbinding_b64 is not saved to the spool file, since it's
484 only available for use for authenticators while this TLS session is running. */
485
486 tls_channelbinding_b64 = NULL;
487 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
488 channel.data = NULL;
489 channel.size = 0;
490 if ((rc = gnutls_session_channel_binding(state->session, GNUTLS_CB_TLS_UNIQUE, &channel)))
491   { DEBUG(D_tls) debug_printf("Channel binding error: %s\n", gnutls_strerror(rc)); }
492 else
493   {
494   old_pool = store_pool;
495   store_pool = POOL_PERM;
496   tls_channelbinding_b64 = b64encode(CUS channel.data, (int)channel.size);
497   store_pool = old_pool;
498   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage.\n");
499   }
500 #endif
501
502 /* peercert is set in peer_status() */
503 tlsp->peerdn = state->peerdn;
504 tlsp->sni =    state->received_sni;
505
506 /* record our certificate */
507   {
508   const gnutls_datum_t * cert = gnutls_certificate_get_ours(state->session);
509   gnutls_x509_crt_t crt;
510
511   tlsp->ourcert = cert && import_cert(cert, &crt)==0 ? crt : NULL;
512   }
513 }
514
515
516
517
518 /*************************************************
519 *            Setup up DH parameters              *
520 *************************************************/
521
522 /* Generating the D-H parameters may take a long time. They only need to
523 be re-generated every so often, depending on security policy. What we do is to
524 keep these parameters in a file in the spool directory. If the file does not
525 exist, we generate them. This means that it is easy to cause a regeneration.
526
527 The new file is written as a temporary file and renamed, so that an incomplete
528 file is never present. If two processes both compute some new parameters, you
529 waste a bit of effort, but it doesn't seem worth messing around with locking to
530 prevent this.
531
532 Returns:     OK/DEFER/FAIL
533 */
534
535 static int
536 init_server_dh(uschar ** errstr)
537 {
538 int fd, rc;
539 unsigned int dh_bits;
540 gnutls_datum_t m;
541 uschar filename_buf[PATH_MAX];
542 uschar *filename = NULL;
543 size_t sz;
544 uschar *exp_tls_dhparam;
545 BOOL use_file_in_spool = FALSE;
546 host_item *host = NULL; /* dummy for macros */
547
548 DEBUG(D_tls) debug_printf("Initialising GnuTLS server params.\n");
549
550 if ((rc = gnutls_dh_params_init(&dh_server_params)))
551   return tls_error_gnu(US"gnutls_dh_params_init", rc, host, errstr);
552
553 m.data = NULL;
554 m.size = 0;
555
556 if (!expand_check(tls_dhparam, US"tls_dhparam", &exp_tls_dhparam, errstr))
557   return DEFER;
558
559 if (!exp_tls_dhparam)
560   {
561   DEBUG(D_tls) debug_printf("Loading default hard-coded DH params\n");
562   m.data = US std_dh_prime_default();
563   m.size = Ustrlen(m.data);
564   }
565 else if (Ustrcmp(exp_tls_dhparam, "historic") == 0)
566   use_file_in_spool = TRUE;
567 else if (Ustrcmp(exp_tls_dhparam, "none") == 0)
568   {
569   DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
570   return OK;
571   }
572 else if (exp_tls_dhparam[0] != '/')
573   {
574   if (!(m.data = US std_dh_prime_named(exp_tls_dhparam)))
575     return tls_error(US"No standard prime named", exp_tls_dhparam, NULL, errstr);
576   m.size = Ustrlen(m.data);
577   }
578 else
579   filename = exp_tls_dhparam;
580
581 if (m.data)
582   {
583   if ((rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM)))
584     return tls_error_gnu(US"gnutls_dh_params_import_pkcs3", rc, host, errstr);
585   DEBUG(D_tls) debug_printf("Loaded fixed standard D-H parameters\n");
586   return OK;
587   }
588
589 #ifdef HAVE_GNUTLS_SEC_PARAM_CONSTANTS
590 /* If you change this constant, also change dh_param_fn_ext so that we can use a
591 different filename and ensure we have sufficient bits. */
592
593 if (!(dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, GNUTLS_SEC_PARAM_NORMAL)))
594   return tls_error(US"gnutls_sec_param_to_pk_bits() failed", NULL, NULL, errstr);
595 DEBUG(D_tls)
596   debug_printf("GnuTLS tells us that for D-H PK, NORMAL is %d bits.\n",
597       dh_bits);
598 #else
599 dh_bits = EXIM_SERVER_DH_BITS_PRE2_12;
600 DEBUG(D_tls)
601   debug_printf("GnuTLS lacks gnutls_sec_param_to_pk_bits(), using %d bits.\n",
602       dh_bits);
603 #endif
604
605 /* Some clients have hard-coded limits. */
606 if (dh_bits > tls_dh_max_bits)
607   {
608   DEBUG(D_tls)
609     debug_printf("tls_dh_max_bits clamping override, using %d bits instead.\n",
610         tls_dh_max_bits);
611   dh_bits = tls_dh_max_bits;
612   }
613
614 if (use_file_in_spool)
615   {
616   if (!string_format(filename_buf, sizeof(filename_buf),
617         "%s/gnutls-params-%d", spool_directory, dh_bits))
618     return tls_error(US"overlong filename", NULL, NULL, errstr);
619   filename = filename_buf;
620   }
621
622 /* Open the cache file for reading and if successful, read it and set up the
623 parameters. */
624
625 if ((fd = Uopen(filename, O_RDONLY, 0)) >= 0)
626   {
627   struct stat statbuf;
628   FILE *fp;
629   int saved_errno;
630
631   if (fstat(fd, &statbuf) < 0)  /* EIO */
632     {
633     saved_errno = errno;
634     (void)close(fd);
635     return tls_error_sys(US"TLS cache stat failed", saved_errno, NULL, errstr);
636     }
637   if (!S_ISREG(statbuf.st_mode))
638     {
639     (void)close(fd);
640     return tls_error(US"TLS cache not a file", NULL, NULL, errstr);
641     }
642   if (!(fp = fdopen(fd, "rb")))
643     {
644     saved_errno = errno;
645     (void)close(fd);
646     return tls_error_sys(US"fdopen(TLS cache stat fd) failed",
647         saved_errno, NULL, errstr);
648     }
649
650   m.size = statbuf.st_size;
651   if (!(m.data = store_malloc(m.size)))
652     {
653     fclose(fp);
654     return tls_error_sys(US"malloc failed", errno, NULL, errstr);
655     }
656   if (!(sz = fread(m.data, m.size, 1, fp)))
657     {
658     saved_errno = errno;
659     fclose(fp);
660     store_free(m.data);
661     return tls_error_sys(US"fread failed", saved_errno, NULL, errstr);
662     }
663   fclose(fp);
664
665   rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM);
666   store_free(m.data);
667   if (rc)
668     return tls_error_gnu(US"gnutls_dh_params_import_pkcs3", rc, host, errstr);
669   DEBUG(D_tls) debug_printf("read D-H parameters from file \"%s\"\n", filename);
670   }
671
672 /* If the file does not exist, fall through to compute new data and cache it.
673 If there was any other opening error, it is serious. */
674
675 else if (errno == ENOENT)
676   {
677   rc = -1;
678   DEBUG(D_tls)
679     debug_printf("D-H parameter cache file \"%s\" does not exist\n", filename);
680   }
681 else
682   return tls_error(string_open_failed(errno, "\"%s\" for reading", filename),
683       NULL, NULL, errstr);
684
685 /* If ret < 0, either the cache file does not exist, or the data it contains
686 is not useful. One particular case of this is when upgrading from an older
687 release of Exim in which the data was stored in a different format. We don't
688 try to be clever and support both formats; we just regenerate new data in this
689 case. */
690
691 if (rc < 0)
692   {
693   uschar *temp_fn;
694   unsigned int dh_bits_gen = dh_bits;
695
696   if ((PATH_MAX - Ustrlen(filename)) < 10)
697     return tls_error(US"Filename too long to generate replacement",
698         filename, NULL, errstr);
699
700   temp_fn = string_copy(US"%s.XXXXXXX");
701   if ((fd = mkstemp(CS temp_fn)) < 0)   /* modifies temp_fn */
702     return tls_error_sys(US"Unable to open temp file", errno, NULL, errstr);
703   (void)exim_chown(temp_fn, exim_uid, exim_gid);   /* Probably not necessary */
704
705   /* GnuTLS overshoots!
706    * If we ask for 2236, we might get 2237 or more.
707    * But there's no way to ask GnuTLS how many bits there really are.
708    * We can ask how many bits were used in a TLS session, but that's it!
709    * The prime itself is hidden behind too much abstraction.
710    * So we ask for less, and proceed on a wing and a prayer.
711    * First attempt, subtracted 3 for 2233 and got 2240.
712    */
713   if (dh_bits >= EXIM_CLIENT_DH_MIN_BITS + 10)
714     {
715     dh_bits_gen = dh_bits - 10;
716     DEBUG(D_tls)
717       debug_printf("being paranoid about DH generation, make it '%d' bits'\n",
718           dh_bits_gen);
719     }
720
721   DEBUG(D_tls)
722     debug_printf("requesting generation of %d bit Diffie-Hellman prime ...\n",
723         dh_bits_gen);
724   if ((rc = gnutls_dh_params_generate2(dh_server_params, dh_bits_gen)))
725     return tls_error_gnu(US"gnutls_dh_params_generate2", rc, host, errstr);
726
727   /* gnutls_dh_params_export_pkcs3() will tell us the exact size, every time,
728   and I confirmed that a NULL call to get the size first is how the GnuTLS
729   sample apps handle this. */
730
731   sz = 0;
732   m.data = NULL;
733   if (  (rc = gnutls_dh_params_export_pkcs3(dh_server_params,
734                 GNUTLS_X509_FMT_PEM, m.data, &sz))
735      && rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
736     return tls_error_gnu(US"gnutls_dh_params_export_pkcs3(NULL) sizing",
737               rc, host, errstr);
738   m.size = sz;
739   if (!(m.data = store_malloc(m.size)))
740     return tls_error_sys(US"memory allocation failed", errno, NULL, errstr);
741
742   /* this will return a size 1 less than the allocation size above */
743   if ((rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
744       m.data, &sz)))
745     {
746     store_free(m.data);
747     return tls_error_gnu(US"gnutls_dh_params_export_pkcs3() real", rc, host, errstr);
748     }
749   m.size = sz; /* shrink by 1, probably */
750
751   if ((sz = write_to_fd_buf(fd, m.data, (size_t) m.size)) != m.size)
752     {
753     store_free(m.data);
754     return tls_error_sys(US"TLS cache write D-H params failed",
755         errno, NULL, errstr);
756     }
757   store_free(m.data);
758   if ((sz = write_to_fd_buf(fd, US"\n", 1)) != 1)
759     return tls_error_sys(US"TLS cache write D-H params final newline failed",
760         errno, NULL, errstr);
761
762   if ((rc = close(fd)))
763     return tls_error_sys(US"TLS cache write close() failed", errno, NULL, errstr);
764
765   if (Urename(temp_fn, filename) < 0)
766     return tls_error_sys(string_sprintf("failed to rename \"%s\" as \"%s\"",
767           temp_fn, filename), errno, NULL, errstr);
768
769   DEBUG(D_tls) debug_printf("wrote D-H parameters to file \"%s\"\n", filename);
770   }
771
772 DEBUG(D_tls) debug_printf("initialized server D-H parameters\n");
773 return OK;
774 }
775
776
777
778
779 /* Create and install a selfsigned certificate, for use in server mode */
780
781 static int
782 tls_install_selfsign(exim_gnutls_state_st * state, uschar ** errstr)
783 {
784 gnutls_x509_crt_t cert = NULL;
785 time_t now;
786 gnutls_x509_privkey_t pkey = NULL;
787 const uschar * where;
788 int rc;
789
790 where = US"initialising pkey";
791 if ((rc = gnutls_x509_privkey_init(&pkey))) goto err;
792
793 where = US"initialising cert";
794 if ((rc = gnutls_x509_crt_init(&cert))) goto err;
795
796 where = US"generating pkey";
797 if ((rc = gnutls_x509_privkey_generate(pkey, GNUTLS_PK_RSA,
798 #ifdef SUPPORT_PARAM_TO_PK_BITS
799 # ifndef GNUTLS_SEC_PARAM_MEDIUM
800 #  define GNUTLS_SEC_PARAM_MEDIUM GNUTLS_SEC_PARAM_HIGH
801 # endif
802             gnutls_sec_param_to_pk_bits(GNUTLS_PK_RSA, GNUTLS_SEC_PARAM_MEDIUM),
803 #else
804             2048,
805 #endif
806             0)))
807   goto err;
808
809 where = US"configuring cert";
810 now = 1;
811 if (  (rc = gnutls_x509_crt_set_version(cert, 3))
812    || (rc = gnutls_x509_crt_set_serial(cert, &now, sizeof(now)))
813    || (rc = gnutls_x509_crt_set_activation_time(cert, now = time(NULL)))
814    || (rc = gnutls_x509_crt_set_expiration_time(cert, now + 60 * 60)) /* 1 hr */
815    || (rc = gnutls_x509_crt_set_key(cert, pkey))
816
817    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
818               GNUTLS_OID_X520_COUNTRY_NAME, 0, "UK", 2))
819    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
820               GNUTLS_OID_X520_ORGANIZATION_NAME, 0, "Exim Developers", 15))
821    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
822               GNUTLS_OID_X520_COMMON_NAME, 0,
823               smtp_active_hostname, Ustrlen(smtp_active_hostname)))
824    )
825   goto err;
826
827 where = US"signing cert";
828 if ((rc = gnutls_x509_crt_sign(cert, cert, pkey))) goto err;
829
830 where = US"installing selfsign cert";
831                                         /* Since: 2.4.0 */
832 if ((rc = gnutls_certificate_set_x509_key(state->x509_cred, &cert, 1, pkey)))
833   goto err;
834
835 rc = OK;
836
837 out:
838   if (cert) gnutls_x509_crt_deinit(cert);
839   if (pkey) gnutls_x509_privkey_deinit(pkey);
840   return rc;
841
842 err:
843   rc = tls_error_gnu(where, rc, NULL, errstr);
844   goto out;
845 }
846
847
848
849
850 /* Add certificate and key, from files.
851
852 Return:
853   Zero or negative: good.  Negate value for certificate index if < 0.
854   Greater than zero: FAIL or DEFER code.
855 */
856
857 static int
858 tls_add_certfile(exim_gnutls_state_st * state, const host_item * host,
859   uschar * certfile, uschar * keyfile, uschar ** errstr)
860 {
861 int rc = gnutls_certificate_set_x509_key_file(state->x509_cred,
862     CS certfile, CS keyfile, GNUTLS_X509_FMT_PEM);
863 if (rc < 0)
864   return tls_error_gnu(
865     string_sprintf("cert/key setup: cert=%s key=%s", certfile, keyfile),
866     rc, host, errstr);
867 return -rc;
868 }
869
870
871 /*************************************************
872 *       Variables re-expanded post-SNI           *
873 *************************************************/
874
875 /* Called from both server and client code, via tls_init(), and also from
876 the SNI callback after receiving an SNI, if tls_certificate includes "tls_sni".
877
878 We can tell the two apart by state->received_sni being non-NULL in callback.
879
880 The callback should not call us unless state->trigger_sni_changes is true,
881 which we are responsible for setting on the first pass through.
882
883 Arguments:
884   state           exim_gnutls_state_st *
885   errstr          error string pointer
886
887 Returns:          OK/DEFER/FAIL
888 */
889
890 static int
891 tls_expand_session_files(exim_gnutls_state_st * state, uschar ** errstr)
892 {
893 struct stat statbuf;
894 int rc;
895 const host_item *host = state->host;  /* macro should be reconsidered? */
896 uschar *saved_tls_certificate = NULL;
897 uschar *saved_tls_privatekey = NULL;
898 uschar *saved_tls_verify_certificates = NULL;
899 uschar *saved_tls_crl = NULL;
900 int cert_count;
901
902 /* We check for tls_sni *before* expansion. */
903 if (!host)      /* server */
904   if (!state->received_sni)
905     {
906     if (  state->tls_certificate
907        && (  Ustrstr(state->tls_certificate, US"tls_sni")
908           || Ustrstr(state->tls_certificate, US"tls_in_sni")
909           || Ustrstr(state->tls_certificate, US"tls_out_sni")
910        )  )
911       {
912       DEBUG(D_tls) debug_printf("We will re-expand TLS session files if we receive SNI.\n");
913       state->trigger_sni_changes = TRUE;
914       }
915     }
916   else
917     {
918     /* useful for debugging */
919     saved_tls_certificate = state->exp_tls_certificate;
920     saved_tls_privatekey = state->exp_tls_privatekey;
921     saved_tls_verify_certificates = state->exp_tls_verify_certificates;
922     saved_tls_crl = state->exp_tls_crl;
923     }
924
925 if ((rc = gnutls_certificate_allocate_credentials(&state->x509_cred)))
926   return tls_error_gnu(US"gnutls_certificate_allocate_credentials",
927             rc, host, errstr);
928
929 #ifdef SUPPORT_SRV_OCSP_STACK
930 gnutls_certificate_set_flags(state->x509_cred, GNUTLS_CERTIFICATE_API_V2);
931 #endif
932
933 /* remember: expand_check_tlsvar() is expand_check() but fiddling with
934 state members, assuming consistent naming; and expand_check() returns
935 false if expansion failed, unless expansion was forced to fail. */
936
937 /* check if we at least have a certificate, before doing expensive
938 D-H generation. */
939
940 if (!expand_check_tlsvar(tls_certificate, errstr))
941   return DEFER;
942
943 /* certificate is mandatory in server, optional in client */
944
945 if (  !state->exp_tls_certificate
946    || !*state->exp_tls_certificate
947    )
948   if (!host)
949     return tls_install_selfsign(state, errstr);
950   else
951     DEBUG(D_tls) debug_printf("TLS: no client certificate specified; okay\n");
952
953 if (state->tls_privatekey && !expand_check_tlsvar(tls_privatekey, errstr))
954   return DEFER;
955
956 /* tls_privatekey is optional, defaulting to same file as certificate */
957
958 if (state->tls_privatekey == NULL || *state->tls_privatekey == '\0')
959   {
960   state->tls_privatekey = state->tls_certificate;
961   state->exp_tls_privatekey = state->exp_tls_certificate;
962   }
963
964
965 if (state->exp_tls_certificate && *state->exp_tls_certificate)
966   {
967   DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
968       state->exp_tls_certificate, state->exp_tls_privatekey);
969
970   if (state->received_sni)
971     if (  Ustrcmp(state->exp_tls_certificate, saved_tls_certificate) == 0
972        && Ustrcmp(state->exp_tls_privatekey,  saved_tls_privatekey)  == 0
973        )
974       {
975       DEBUG(D_tls) debug_printf("TLS SNI: cert and key unchanged\n");
976       }
977     else
978       {
979       DEBUG(D_tls) debug_printf("TLS SNI: have a changed cert/key pair.\n");
980       }
981
982   if (!host)    /* server */
983     {
984     const uschar * clist = state->exp_tls_certificate;
985     const uschar * klist = state->exp_tls_privatekey;
986     const uschar * olist;
987     int csep = 0, ksep = 0, osep = 0, cnt = 0;
988     uschar * cfile, * kfile, * ofile;
989
990 #ifndef DISABLE_OCSP
991     if (!expand_check(tls_ocsp_file, US"tls_ocsp_file", &ofile, errstr))
992       return DEFER;
993     olist = ofile;
994 #endif
995
996     while (cfile = string_nextinlist(&clist, &csep, NULL, 0))
997
998       if (!(kfile = string_nextinlist(&klist, &ksep, NULL, 0)))
999         return tls_error(US"cert/key setup: out of keys", NULL, host, errstr);
1000       else if (0 < (rc = tls_add_certfile(state, host, cfile, kfile, errstr)))
1001         return rc;
1002       else
1003         {
1004         int gnutls_cert_index = -rc;
1005         DEBUG(D_tls) debug_printf("TLS: cert/key %s registered\n", cfile);
1006
1007         /* Set the OCSP stapling server info */
1008
1009 #ifndef DISABLE_OCSP
1010         if (tls_ocsp_file)
1011           if (gnutls_buggy_ocsp)
1012             {
1013             DEBUG(D_tls)
1014               debug_printf("GnuTLS library is buggy for OCSP; avoiding\n");
1015             }
1016           else if ((ofile = string_nextinlist(&olist, &osep, NULL, 0)))
1017             {
1018             /* Use the full callback method for stapling just to get
1019             observability.  More efficient would be to read the file once only,
1020             if it never changed (due to SNI). Would need restart on file update,
1021             or watch datestamp.  */
1022
1023 # ifdef SUPPORT_SRV_OCSP_STACK
1024             if ((rc = gnutls_certificate_set_ocsp_status_request_function2(
1025                         state->x509_cred, gnutls_cert_index,
1026                         server_ocsp_stapling_cb, ofile)))
1027               return tls_error_gnu(
1028                       US"gnutls_certificate_set_ocsp_status_request_function2",
1029                       rc, host, errstr);
1030 # else
1031             if (cnt++ > 0)
1032               {
1033               DEBUG(D_tls)
1034                 debug_printf("oops; multiple OCSP files not supported\n");
1035               break;
1036               }
1037               gnutls_certificate_set_ocsp_status_request_function(
1038                 state->x509_cred, server_ocsp_stapling_cb, ofile);
1039 # endif
1040
1041             DEBUG(D_tls) debug_printf("OCSP response file = %s\n", ofile);
1042             }
1043           else
1044             DEBUG(D_tls) debug_printf("ran out of OCSP response files in list\n");
1045 #endif
1046         }
1047     }
1048   else
1049     {
1050     if (0 < (rc = tls_add_certfile(state, host,
1051                 state->exp_tls_certificate, state->exp_tls_privatekey, errstr)))
1052       return rc;
1053     DEBUG(D_tls) debug_printf("TLS: cert/key registered\n");
1054     }
1055
1056   } /* tls_certificate */
1057
1058
1059 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
1060 provided. Experiment shows that, if the certificate file is empty, an unhelpful
1061 error message is provided. However, if we just refrain from setting anything up
1062 in that case, certificate verification fails, which seems to be the correct
1063 behaviour. */
1064
1065 if (state->tls_verify_certificates && *state->tls_verify_certificates)
1066   {
1067   if (!expand_check_tlsvar(tls_verify_certificates, errstr))
1068     return DEFER;
1069 #ifndef SUPPORT_SYSDEFAULT_CABUNDLE
1070   if (Ustrcmp(state->exp_tls_verify_certificates, "system") == 0)
1071     state->exp_tls_verify_certificates = NULL;
1072 #endif
1073   if (state->tls_crl && *state->tls_crl)
1074     if (!expand_check_tlsvar(tls_crl, errstr))
1075       return DEFER;
1076
1077   if (!(state->exp_tls_verify_certificates &&
1078         *state->exp_tls_verify_certificates))
1079     {
1080     DEBUG(D_tls)
1081       debug_printf("TLS: tls_verify_certificates expanded empty, ignoring\n");
1082     /* With no tls_verify_certificates, we ignore tls_crl too */
1083     return OK;
1084     }
1085   }
1086 else
1087   {
1088   DEBUG(D_tls)
1089     debug_printf("TLS: tls_verify_certificates not set or empty, ignoring\n");
1090   return OK;
1091   }
1092
1093 #ifdef SUPPORT_SYSDEFAULT_CABUNDLE
1094 if (Ustrcmp(state->exp_tls_verify_certificates, "system") == 0)
1095   cert_count = gnutls_certificate_set_x509_system_trust(state->x509_cred);
1096 else
1097 #endif
1098   {
1099   if (Ustat(state->exp_tls_verify_certificates, &statbuf) < 0)
1100     {
1101     log_write(0, LOG_MAIN|LOG_PANIC, "could not stat %s "
1102         "(tls_verify_certificates): %s", state->exp_tls_verify_certificates,
1103         strerror(errno));
1104     return DEFER;
1105     }
1106
1107 #ifndef SUPPORT_CA_DIR
1108   /* The test suite passes in /dev/null; we could check for that path explicitly,
1109   but who knows if someone has some weird FIFO which always dumps some certs, or
1110   other weirdness.  The thing we really want to check is that it's not a
1111   directory, since while OpenSSL supports that, GnuTLS does not.
1112   So s/!S_ISREG/S_ISDIR/ and change some messaging ... */
1113   if (S_ISDIR(statbuf.st_mode))
1114     {
1115     DEBUG(D_tls)
1116       debug_printf("verify certificates path is a dir: \"%s\"\n",
1117           state->exp_tls_verify_certificates);
1118     log_write(0, LOG_MAIN|LOG_PANIC,
1119         "tls_verify_certificates \"%s\" is a directory",
1120         state->exp_tls_verify_certificates);
1121     return DEFER;
1122     }
1123 #endif
1124
1125   DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
1126           state->exp_tls_verify_certificates, statbuf.st_size);
1127
1128   if (statbuf.st_size == 0)
1129     {
1130     DEBUG(D_tls)
1131       debug_printf("cert file empty, no certs, no verification, ignoring any CRL\n");
1132     return OK;
1133     }
1134
1135   cert_count =
1136
1137 #ifdef SUPPORT_CA_DIR
1138     (statbuf.st_mode & S_IFMT) == S_IFDIR
1139     ?
1140     gnutls_certificate_set_x509_trust_dir(state->x509_cred,
1141       CS state->exp_tls_verify_certificates, GNUTLS_X509_FMT_PEM)
1142     :
1143 #endif
1144     gnutls_certificate_set_x509_trust_file(state->x509_cred,
1145       CS state->exp_tls_verify_certificates, GNUTLS_X509_FMT_PEM);
1146
1147 #ifdef SUPPORT_CA_DIR
1148   /* Mimic the behaviour with OpenSSL of not advertising a usable-cert list
1149   when using the directory-of-certs config model. */
1150
1151   if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1152     gnutls_certificate_send_x509_rdn_sequence(state->session, 1);
1153 #endif
1154   }
1155
1156 if (cert_count < 0)
1157   return tls_error_gnu(US"setting certificate trust", cert_count, host, errstr);
1158 DEBUG(D_tls)
1159   debug_printf("Added %d certificate authorities.\n", cert_count);
1160
1161 if (state->tls_crl && *state->tls_crl &&
1162     state->exp_tls_crl && *state->exp_tls_crl)
1163   {
1164   DEBUG(D_tls) debug_printf("loading CRL file = %s\n", state->exp_tls_crl);
1165   if ((cert_count = gnutls_certificate_set_x509_crl_file(state->x509_cred,
1166       CS state->exp_tls_crl, GNUTLS_X509_FMT_PEM)) < 0)
1167     return tls_error_gnu(US"gnutls_certificate_set_x509_crl_file",
1168               cert_count, host, errstr);
1169
1170   DEBUG(D_tls) debug_printf("Processed %d CRLs.\n", cert_count);
1171   }
1172
1173 return OK;
1174 }
1175
1176
1177
1178
1179 /*************************************************
1180 *          Set X.509 state variables             *
1181 *************************************************/
1182
1183 /* In GnuTLS, the registered cert/key are not replaced by a later
1184 set of a cert/key, so for SNI support we need a whole new x509_cred
1185 structure.  Which means various other non-re-expanded pieces of state
1186 need to be re-set in the new struct, so the setting logic is pulled
1187 out to this.
1188
1189 Arguments:
1190   state           exim_gnutls_state_st *
1191   errstr          error string pointer
1192
1193 Returns:          OK/DEFER/FAIL
1194 */
1195
1196 static int
1197 tls_set_remaining_x509(exim_gnutls_state_st *state, uschar ** errstr)
1198 {
1199 int rc;
1200 const host_item *host = state->host;  /* macro should be reconsidered? */
1201
1202 /* Create D-H parameters, or read them from the cache file. This function does
1203 its own SMTP error messaging. This only happens for the server, TLS D-H ignores
1204 client-side params. */
1205
1206 if (!state->host)
1207   {
1208   if (!dh_server_params)
1209     if ((rc = init_server_dh(errstr)) != OK) return rc;
1210   gnutls_certificate_set_dh_params(state->x509_cred, dh_server_params);
1211   }
1212
1213 /* Link the credentials to the session. */
1214
1215 if ((rc = gnutls_credentials_set(state->session,
1216             GNUTLS_CRD_CERTIFICATE, state->x509_cred)))
1217   return tls_error_gnu(US"gnutls_credentials_set", rc, host, errstr);
1218
1219 return OK;
1220 }
1221
1222 /*************************************************
1223 *            Initialize for GnuTLS               *
1224 *************************************************/
1225
1226
1227 #ifndef DISABLE_OCSP
1228
1229 static BOOL
1230 tls_is_buggy_ocsp(void)
1231 {
1232 const uschar * s;
1233 uschar maj, mid, mic;
1234
1235 s = CUS gnutls_check_version(NULL);
1236 maj = atoi(CCS s);
1237 if (maj == 3)
1238   {
1239   while (*s && *s != '.') s++;
1240   mid = atoi(CCS ++s);
1241   if (mid <= 2)
1242     return TRUE;
1243   else if (mid >= 5)
1244     return FALSE;
1245   else
1246     {
1247     while (*s && *s != '.') s++;
1248     mic = atoi(CCS ++s);
1249     return mic <= (mid == 3 ? 16 : 3);
1250     }
1251   }
1252 return FALSE;
1253 }
1254
1255 #endif
1256
1257
1258 /* Called from both server and client code. In the case of a server, errors
1259 before actual TLS negotiation return DEFER.
1260
1261 Arguments:
1262   host            connected host, if client; NULL if server
1263   certificate     certificate file
1264   privatekey      private key file
1265   sni             TLS SNI to send, sometimes when client; else NULL
1266   cas             CA certs file
1267   crl             CRL file
1268   require_ciphers tls_require_ciphers setting
1269   caller_state    returned state-info structure
1270   errstr          error string pointer
1271
1272 Returns:          OK/DEFER/FAIL
1273 */
1274
1275 static int
1276 tls_init(
1277     const host_item *host,
1278     const uschar *certificate,
1279     const uschar *privatekey,
1280     const uschar *sni,
1281     const uschar *cas,
1282     const uschar *crl,
1283     const uschar *require_ciphers,
1284     exim_gnutls_state_st **caller_state,
1285     tls_support * tlsp,
1286     uschar ** errstr)
1287 {
1288 exim_gnutls_state_st * state;
1289 int rc;
1290 size_t sz;
1291 const char * errpos;
1292 const uschar * p;
1293
1294 if (!exim_gnutls_base_init_done)
1295   {
1296   DEBUG(D_tls) debug_printf("GnuTLS global init required.\n");
1297
1298 #ifdef HAVE_GNUTLS_PKCS11
1299   /* By default, gnutls_global_init will init PKCS11 support in auto mode,
1300   which loads modules from a config file, which sounds good and may be wanted
1301   by some sysadmin, but also means in common configurations that GNOME keyring
1302   environment variables are used and so breaks for users calling mailq.
1303   To prevent this, we init PKCS11 first, which is the documented approach. */
1304   if (!gnutls_allow_auto_pkcs11)
1305     if ((rc = gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_MANUAL, NULL)))
1306       return tls_error_gnu(US"gnutls_pkcs11_init", rc, host, errstr);
1307 #endif
1308
1309   if ((rc = gnutls_global_init()))
1310     return tls_error_gnu(US"gnutls_global_init", rc, host, errstr);
1311
1312 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
1313   DEBUG(D_tls)
1314     {
1315     gnutls_global_set_log_function(exim_gnutls_logger_cb);
1316     /* arbitrarily chosen level; bump up to 9 for more */
1317     gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL);
1318     }
1319 #endif
1320
1321 #ifndef DISABLE_OCSP
1322   if (tls_ocsp_file && (gnutls_buggy_ocsp = tls_is_buggy_ocsp()))
1323     log_write(0, LOG_MAIN, "OCSP unusable with this GnuTLS library version");
1324 #endif
1325
1326   exim_gnutls_base_init_done = TRUE;
1327   }
1328
1329 if (host)
1330   {
1331   /* For client-side sessions we allocate a context. This lets us run
1332   several in parallel. */
1333   int old_pool = store_pool;
1334   store_pool = POOL_PERM;
1335   state = store_get(sizeof(exim_gnutls_state_st), FALSE);
1336   store_pool = old_pool;
1337
1338   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
1339   state->tlsp = tlsp;
1340   DEBUG(D_tls) debug_printf("initialising GnuTLS client session\n");
1341   rc = gnutls_init(&state->session, GNUTLS_CLIENT);
1342   }
1343 else
1344   {
1345   state = &state_server;
1346   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
1347   state->tlsp = tlsp;
1348   DEBUG(D_tls) debug_printf("initialising GnuTLS server session\n");
1349   rc = gnutls_init(&state->session, GNUTLS_SERVER);
1350   }
1351 if (rc)
1352   return tls_error_gnu(US"gnutls_init", rc, host, errstr);
1353
1354 state->host = host;
1355
1356 state->tls_certificate = certificate;
1357 state->tls_privatekey = privatekey;
1358 state->tls_require_ciphers = require_ciphers;
1359 state->tls_sni = sni;
1360 state->tls_verify_certificates = cas;
1361 state->tls_crl = crl;
1362
1363 /* This handles the variables that might get re-expanded after TLS SNI;
1364 that's tls_certificate, tls_privatekey, tls_verify_certificates, tls_crl */
1365
1366 DEBUG(D_tls)
1367   debug_printf("Expanding various TLS configuration options for session credentials.\n");
1368 if ((rc = tls_expand_session_files(state, errstr)) != OK) return rc;
1369
1370 /* These are all other parts of the x509_cred handling, since SNI in GnuTLS
1371 requires a new structure afterwards. */
1372
1373 if ((rc = tls_set_remaining_x509(state, errstr)) != OK) return rc;
1374
1375 /* set SNI in client, only */
1376 if (host)
1377   {
1378   if (!expand_check(sni, US"tls_out_sni", &state->tlsp->sni, errstr))
1379     return DEFER;
1380   if (state->tlsp->sni && *state->tlsp->sni)
1381     {
1382     DEBUG(D_tls)
1383       debug_printf("Setting TLS client SNI to \"%s\"\n", state->tlsp->sni);
1384     sz = Ustrlen(state->tlsp->sni);
1385     if ((rc = gnutls_server_name_set(state->session,
1386           GNUTLS_NAME_DNS, state->tlsp->sni, sz)))
1387       return tls_error_gnu(US"gnutls_server_name_set", rc, host, errstr);
1388     }
1389   }
1390 else if (state->tls_sni)
1391   DEBUG(D_tls) debug_printf("*** PROBABLY A BUG *** " \
1392       "have an SNI set for a server [%s]\n", state->tls_sni);
1393
1394 /* This is the priority string support,
1395 http://www.gnutls.org/manual/html_node/Priority-Strings.html
1396 and replaces gnutls_require_kx, gnutls_require_mac & gnutls_require_protocols.
1397 This was backwards incompatible, but means Exim no longer needs to track
1398 all algorithms and provide string forms for them. */
1399
1400 p = NULL;
1401 if (state->tls_require_ciphers && *state->tls_require_ciphers)
1402   {
1403   if (!expand_check_tlsvar(tls_require_ciphers, errstr))
1404     return DEFER;
1405   if (state->exp_tls_require_ciphers && *state->exp_tls_require_ciphers)
1406     {
1407     p = state->exp_tls_require_ciphers;
1408     DEBUG(D_tls) debug_printf("GnuTLS session cipher/priority \"%s\"\n", p);
1409     }
1410   }
1411 if (!p)
1412   {
1413   p = exim_default_gnutls_priority;
1414   DEBUG(D_tls)
1415     debug_printf("GnuTLS using default session cipher/priority \"%s\"\n", p);
1416   }
1417
1418 if ((rc = gnutls_priority_init(&state->priority_cache, CCS p, &errpos)))
1419   return tls_error_gnu(string_sprintf(
1420                       "gnutls_priority_init(%s) failed at offset %ld, \"%.6s..\"",
1421                       p, errpos - CS p, errpos),
1422                   rc, host, errstr);
1423
1424 if ((rc = gnutls_priority_set(state->session, state->priority_cache)))
1425   return tls_error_gnu(US"gnutls_priority_set", rc, host, errstr);
1426
1427 /* This also sets the server ticket expiration time to the same, and
1428 the STEK rotation time to 3x. */
1429
1430 gnutls_db_set_cache_expiration(state->session, ssl_session_timeout);
1431
1432 /* Reduce security in favour of increased compatibility, if the admin
1433 decides to make that trade-off. */
1434 if (gnutls_compat_mode)
1435   {
1436 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
1437   DEBUG(D_tls) debug_printf("lowering GnuTLS security, compatibility mode\n");
1438   gnutls_session_enable_compatibility_mode(state->session);
1439 #else
1440   DEBUG(D_tls) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
1441 #endif
1442   }
1443
1444 *caller_state = state;
1445 return OK;
1446 }
1447
1448
1449
1450 /*************************************************
1451 *            Extract peer information            *
1452 *************************************************/
1453
1454 static const uschar *
1455 cipher_stdname_kcm(gnutls_kx_algorithm_t kx, gnutls_cipher_algorithm_t cipher,
1456   gnutls_mac_algorithm_t mac)
1457 {
1458 uschar cs_id[2];
1459 gnutls_kx_algorithm_t kx_i;
1460 gnutls_cipher_algorithm_t cipher_i;
1461 gnutls_mac_algorithm_t mac_i;
1462
1463 for (size_t i = 0;
1464      gnutls_cipher_suite_info(i, cs_id, &kx_i, &cipher_i, &mac_i, NULL);
1465      i++)
1466   if (kx_i == kx && cipher_i == cipher && mac_i == mac)
1467     return cipher_stdname(cs_id[0], cs_id[1]);
1468 return NULL;
1469 }
1470
1471
1472
1473 /* Called from both server and client code.
1474 Only this is allowed to set state->peerdn and state->have_set_peerdn
1475 and we use that to detect double-calls.
1476
1477 NOTE: the state blocks last while the TLS connection is up, which is fine
1478 for logging in the server side, but for the client side, we log after teardown
1479 in src/deliver.c.  While the session is up, we can twist about states and
1480 repoint tls_* globals, but those variables used for logging or other variable
1481 expansion that happens _after_ delivery need to have a longer life-time.
1482
1483 So for those, we get the data from POOL_PERM; the re-invoke guard keeps us from
1484 doing this more than once per generation of a state context.  We set them in
1485 the state context, and repoint tls_* to them.  After the state goes away, the
1486 tls_* copies of the pointers remain valid and client delivery logging is happy.
1487
1488 tls_certificate_verified is a BOOL, so the tls_peerdn and tls_cipher issues
1489 don't apply.
1490
1491 Arguments:
1492   state           exim_gnutls_state_st *
1493   errstr          pointer to error string
1494
1495 Returns:          OK/DEFER/FAIL
1496 */
1497
1498 static int
1499 peer_status(exim_gnutls_state_st * state, uschar ** errstr)
1500 {
1501 gnutls_session_t session = state->session;
1502 const gnutls_datum_t * cert_list;
1503 int old_pool, rc;
1504 unsigned int cert_list_size = 0;
1505 gnutls_protocol_t protocol;
1506 gnutls_cipher_algorithm_t cipher;
1507 gnutls_kx_algorithm_t kx;
1508 gnutls_mac_algorithm_t mac;
1509 gnutls_certificate_type_t ct;
1510 gnutls_x509_crt_t crt;
1511 uschar * dn_buf;
1512 size_t sz;
1513
1514 if (state->have_set_peerdn)
1515   return OK;
1516 state->have_set_peerdn = TRUE;
1517
1518 state->peerdn = NULL;
1519
1520 /* tls_cipher */
1521 cipher = gnutls_cipher_get(session);
1522 protocol = gnutls_protocol_get_version(session);
1523 mac = gnutls_mac_get(session);
1524 kx =
1525 #ifdef GNUTLS_TLS1_3
1526     protocol >= GNUTLS_TLS1_3 ? 0 :
1527 #endif
1528   gnutls_kx_get(session);
1529
1530 old_pool = store_pool;
1531   {
1532   tls_support * tlsp = state->tlsp;
1533   store_pool = POOL_PERM;
1534
1535 #ifdef SUPPORT_GNUTLS_SESS_DESC
1536     {
1537     gstring * g = NULL;
1538     uschar * s = US gnutls_session_get_desc(session), c;
1539
1540     /* Nikos M suggests we use this by preference.  It returns like:
1541     (TLS1.3)-(ECDHE-SECP256R1)-(RSA-PSS-RSAE-SHA256)-(AES-256-GCM)
1542
1543     For partial back-compat, put a colon after the TLS version, replace the
1544     )-( grouping with __, replace in-group - with _ and append the :keysize. */
1545
1546     /* debug_printf("peer_status: gnutls_session_get_desc %s\n", s); */
1547
1548     for (s++; (c = *s) && c != ')'; s++) g = string_catn(g, s, 1);
1549     g = string_catn(g, US":", 1);
1550     if (*s) s++;                /* now on _ between groups */
1551     while ((c = *s))
1552       {
1553       for (*++s && ++s; (c = *s) && c != ')'; s++) g = string_catn(g, c == '-' ? US"_" : s, 1);
1554       /* now on ) closing group */
1555       if ((c = *s) && *++s == '-') g = string_catn(g, US"__", 2);
1556       /* now on _ between groups */
1557       }
1558     g = string_catn(g, US":", 1);
1559     g = string_cat(g, string_sprintf("%d", (int) gnutls_cipher_get_key_size(cipher) * 8));
1560     state->ciphersuite = string_from_gstring(g);
1561     }
1562 #else
1563   state->ciphersuite = string_sprintf("%s:%s:%d",
1564       gnutls_protocol_get_name(protocol),
1565       gnutls_cipher_suite_get_name(kx, cipher, mac),
1566       (int) gnutls_cipher_get_key_size(cipher) * 8);
1567
1568   /* I don't see a way that spaces could occur, in the current GnuTLS
1569   code base, but it was a concern in the old code and perhaps older GnuTLS
1570   releases did return "TLS 1.0"; play it safe, just in case. */
1571
1572   for (uschar * p = state->ciphersuite; *p; p++) if (isspace(*p)) *p = '-';
1573 #endif
1574
1575 /* debug_printf("peer_status: ciphersuite %s\n", state->ciphersuite); */
1576
1577   tlsp->cipher = state->ciphersuite;
1578   tlsp->bits = gnutls_cipher_get_key_size(cipher) * 8;
1579
1580   tlsp->cipher_stdname = cipher_stdname_kcm(kx, cipher, mac);
1581   }
1582 store_pool = old_pool;
1583
1584 /* tls_peerdn */
1585 cert_list = gnutls_certificate_get_peers(session, &cert_list_size);
1586
1587 if (!cert_list || cert_list_size == 0)
1588   {
1589   DEBUG(D_tls) debug_printf("TLS: no certificate from peer (%p & %d)\n",
1590       cert_list, cert_list_size);
1591   if (state->verify_requirement >= VERIFY_REQUIRED)
1592     return tls_error(US"certificate verification failed",
1593         US"no certificate received from peer", state->host, errstr);
1594   return OK;
1595   }
1596
1597 if ((ct = gnutls_certificate_type_get(session)) != GNUTLS_CRT_X509)
1598   {
1599   const uschar * ctn = US gnutls_certificate_type_get_name(ct);
1600   DEBUG(D_tls)
1601     debug_printf("TLS: peer cert not X.509 but instead \"%s\"\n", ctn);
1602   if (state->verify_requirement >= VERIFY_REQUIRED)
1603     return tls_error(US"certificate verification not possible, unhandled type",
1604         ctn, state->host, errstr);
1605   return OK;
1606   }
1607
1608 #define exim_gnutls_peer_err(Label) \
1609   do { \
1610     if (rc != GNUTLS_E_SUCCESS) \
1611       { \
1612       DEBUG(D_tls) debug_printf("TLS: peer cert problem: %s: %s\n", \
1613         (Label), gnutls_strerror(rc)); \
1614       if (state->verify_requirement >= VERIFY_REQUIRED) \
1615         return tls_error_gnu((Label), rc, state->host, errstr); \
1616       return OK; \
1617       } \
1618     } while (0)
1619
1620 rc = import_cert(&cert_list[0], &crt);
1621 exim_gnutls_peer_err(US"cert 0");
1622
1623 state->tlsp->peercert = state->peercert = crt;
1624
1625 sz = 0;
1626 rc = gnutls_x509_crt_get_dn(crt, NULL, &sz);
1627 if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
1628   {
1629   exim_gnutls_peer_err(US"getting size for cert DN failed");
1630   return FAIL; /* should not happen */
1631   }
1632 dn_buf = store_get_perm(sz, TRUE);      /* tainted */
1633 rc = gnutls_x509_crt_get_dn(crt, CS dn_buf, &sz);
1634 exim_gnutls_peer_err(US"failed to extract certificate DN [gnutls_x509_crt_get_dn(cert 0)]");
1635
1636 state->peerdn = dn_buf;
1637
1638 return OK;
1639 #undef exim_gnutls_peer_err
1640 }
1641
1642
1643
1644
1645 /*************************************************
1646 *            Verify peer certificate             *
1647 *************************************************/
1648
1649 /* Called from both server and client code.
1650 *Should* be using a callback registered with
1651 gnutls_certificate_set_verify_function() to fail the handshake if we dislike
1652 the peer information, but that's too new for some OSes.
1653
1654 Arguments:
1655   state         exim_gnutls_state_st *
1656   errstr        where to put an error message
1657
1658 Returns:
1659   FALSE     if the session should be rejected
1660   TRUE      if the cert is okay or we just don't care
1661 */
1662
1663 static BOOL
1664 verify_certificate(exim_gnutls_state_st * state, uschar ** errstr)
1665 {
1666 int rc;
1667 uint verify;
1668
1669 DEBUG(D_tls) debug_printf("TLS: checking peer certificate\n");
1670 *errstr = NULL;
1671 rc = peer_status(state, errstr);
1672
1673 if (state->verify_requirement == VERIFY_NONE)
1674   return TRUE;
1675
1676 if (rc != OK || !state->peerdn)
1677   {
1678   verify = GNUTLS_CERT_INVALID;
1679   *errstr = US"certificate not supplied";
1680   }
1681 else
1682
1683   {
1684 #ifdef SUPPORT_DANE
1685   if (state->verify_requirement == VERIFY_DANE && state->host)
1686     {
1687     /* Using dane_verify_session_crt() would be easy, as it does it all for us
1688     including talking to a DNS resolver.  But we want to do that bit ourselves
1689     as the testsuite intercepts and fakes its own DNS environment. */
1690
1691     dane_state_t s;
1692     dane_query_t r;
1693     uint lsize;
1694     const gnutls_datum_t * certlist =
1695       gnutls_certificate_get_peers(state->session, &lsize);
1696     int usage = tls_out.tlsa_usage;
1697
1698 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1699     /* Split the TLSA records into two sets, TA and EE selectors.  Run the
1700     dane-verification separately so that we know which selector verified;
1701     then we know whether to do name-verification (needed for TA but not EE). */
1702
1703     if (usage == ((1<<DANESSL_USAGE_DANE_TA) | (1<<DANESSL_USAGE_DANE_EE)))
1704       {                                         /* a mixed-usage bundle */
1705       int i, j, nrec;
1706       const char ** dd;
1707       int * ddl;
1708
1709       for(nrec = 0; state->dane_data_len[nrec]; ) nrec++;
1710       nrec++;
1711
1712       dd = store_get(nrec * sizeof(uschar *), FALSE);
1713       ddl = store_get(nrec * sizeof(int), FALSE);
1714       nrec--;
1715
1716       if ((rc = dane_state_init(&s, 0)))
1717         goto tlsa_prob;
1718
1719       for (usage = DANESSL_USAGE_DANE_EE;
1720            usage >= DANESSL_USAGE_DANE_TA; usage--)
1721         {                               /* take records with this usage */
1722         for (j = i = 0; i < nrec; i++)
1723           if (state->dane_data[i][0] == usage)
1724             {
1725             dd[j] = state->dane_data[i];
1726             ddl[j++] = state->dane_data_len[i];
1727             }
1728         if (j)
1729           {
1730           dd[j] = NULL;
1731           ddl[j] = 0;
1732
1733           if ((rc = dane_raw_tlsa(s, &r, (char * const *)dd, ddl, 1, 0)))
1734             goto tlsa_prob;
1735
1736           if ((rc = dane_verify_crt_raw(s, certlist, lsize,
1737                             gnutls_certificate_type_get(state->session),
1738                             r, 0,
1739                             usage == DANESSL_USAGE_DANE_EE
1740                             ? DANE_VFLAG_ONLY_CHECK_EE_USAGE : 0,
1741                             &verify)))
1742             {
1743             DEBUG(D_tls)
1744               debug_printf("TLSA record problem: %s\n", dane_strerror(rc));
1745             }
1746           else if (verify == 0) /* verification passed */
1747             {
1748             usage = 1 << usage;
1749             break;
1750             }
1751           }
1752         }
1753
1754         if (rc) goto tlsa_prob;
1755       }
1756     else
1757 # endif
1758       {
1759       if (  (rc = dane_state_init(&s, 0))
1760          || (rc = dane_raw_tlsa(s, &r, state->dane_data, state->dane_data_len,
1761                         1, 0))
1762          || (rc = dane_verify_crt_raw(s, certlist, lsize,
1763                         gnutls_certificate_type_get(state->session),
1764                         r, 0,
1765 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1766                         usage == (1 << DANESSL_USAGE_DANE_EE)
1767                         ? DANE_VFLAG_ONLY_CHECK_EE_USAGE : 0,
1768 # else
1769                         0,
1770 # endif
1771                         &verify))
1772          )
1773         goto tlsa_prob;
1774       }
1775
1776     if (verify != 0)            /* verification failed */
1777       {
1778       gnutls_datum_t str;
1779       (void) dane_verification_status_print(verify, &str, 0);
1780       *errstr = US str.data;    /* don't bother to free */
1781       goto badcert;
1782       }
1783
1784 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1785     /* If a TA-mode TLSA record was used for verification we must additionally
1786     verify the cert name (but not the CA chain).  For EE-mode, skip it. */
1787
1788     if (usage & (1 << DANESSL_USAGE_DANE_EE))
1789 # endif
1790       {
1791       state->peer_dane_verified = state->peer_cert_verified = TRUE;
1792       goto goodcert;
1793       }
1794 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1795     /* Assume that the name on the A-record is the one that should be matching
1796     the cert.  An alternate view is that the domain part of the email address
1797     is also permissible. */
1798
1799     if (gnutls_x509_crt_check_hostname(state->tlsp->peercert,
1800           CS state->host->name))
1801       {
1802       state->peer_dane_verified = state->peer_cert_verified = TRUE;
1803       goto goodcert;
1804       }
1805 # endif
1806     }
1807 #endif  /*SUPPORT_DANE*/
1808
1809   rc = gnutls_certificate_verify_peers2(state->session, &verify);
1810   }
1811
1812 /* Handle the result of verification. INVALID is set if any others are. */
1813
1814 if (rc < 0 || verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
1815   {
1816   state->peer_cert_verified = FALSE;
1817   if (!*errstr)
1818     {
1819 #ifdef GNUTLS_CERT_VFY_STATUS_PRINT
1820     DEBUG(D_tls)
1821       {
1822       gnutls_datum_t txt;
1823
1824       if (gnutls_certificate_verification_status_print(verify,
1825             gnutls_certificate_type_get(state->session), &txt, 0)
1826           == GNUTLS_E_SUCCESS)
1827         {
1828         debug_printf("%s\n", txt.data);
1829         gnutls_free(txt.data);
1830         }
1831       }
1832 #endif
1833     *errstr = verify & GNUTLS_CERT_REVOKED
1834       ? US"certificate revoked" : US"certificate invalid";
1835     }
1836
1837   DEBUG(D_tls)
1838     debug_printf("TLS certificate verification failed (%s): peerdn=\"%s\"\n",
1839         *errstr, state->peerdn ? state->peerdn : US"<unset>");
1840
1841   if (state->verify_requirement >= VERIFY_REQUIRED)
1842     goto badcert;
1843   DEBUG(D_tls)
1844     debug_printf("TLS verify failure overridden (host in tls_try_verify_hosts)\n");
1845   }
1846
1847 else
1848   {
1849   /* Client side, check the server's certificate name versus the name on the
1850   A-record for the connection we made.  What to do for server side - what name
1851   to use for client?  We document that there is no such checking for server
1852   side. */
1853
1854   if (  state->exp_tls_verify_cert_hostnames
1855      && !gnutls_x509_crt_check_hostname(state->tlsp->peercert,
1856                 CS state->exp_tls_verify_cert_hostnames)
1857      )
1858     {
1859     DEBUG(D_tls)
1860       debug_printf("TLS certificate verification failed: cert name mismatch\n");
1861     if (state->verify_requirement >= VERIFY_REQUIRED)
1862       goto badcert;
1863     return TRUE;
1864     }
1865
1866   state->peer_cert_verified = TRUE;
1867   DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=\"%s\"\n",
1868       state->peerdn ? state->peerdn : US"<unset>");
1869   }
1870
1871 goodcert:
1872   state->tlsp->peerdn = state->peerdn;
1873   return TRUE;
1874
1875 #ifdef SUPPORT_DANE
1876 tlsa_prob:
1877   *errstr = string_sprintf("TLSA record problem: %s",
1878     rc == DANE_E_REQUESTED_DATA_NOT_AVAILABLE ? "none usable" : dane_strerror(rc));
1879 #endif
1880
1881 badcert:
1882   gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
1883   return FALSE;
1884 }
1885
1886
1887
1888
1889 /* ------------------------------------------------------------------------ */
1890 /* Callbacks */
1891
1892 /* Logging function which can be registered with
1893  *   gnutls_global_set_log_function()
1894  *   gnutls_global_set_log_level() 0..9
1895  */
1896 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
1897 static void
1898 exim_gnutls_logger_cb(int level, const char *message)
1899 {
1900   size_t len = strlen(message);
1901   if (len < 1)
1902     {
1903     DEBUG(D_tls) debug_printf("GnuTLS<%d> empty debug message\n", level);
1904     return;
1905     }
1906   DEBUG(D_tls) debug_printf("GnuTLS<%d>: %s%s", level, message,
1907       message[len-1] == '\n' ? "" : "\n");
1908 }
1909 #endif
1910
1911
1912 /* Called after client hello, should handle SNI work.
1913 This will always set tls_sni (state->received_sni) if available,
1914 and may trigger presenting different certificates,
1915 if state->trigger_sni_changes is TRUE.
1916
1917 Should be registered with
1918   gnutls_handshake_set_post_client_hello_function()
1919
1920 "This callback must return 0 on success or a gnutls error code to terminate the
1921 handshake.".
1922
1923 For inability to get SNI information, we return 0.
1924 We only return non-zero if re-setup failed.
1925 Only used for server-side TLS.
1926 */
1927
1928 static int
1929 exim_sni_handling_cb(gnutls_session_t session)
1930 {
1931 char sni_name[MAX_HOST_LEN];
1932 size_t data_len = MAX_HOST_LEN;
1933 exim_gnutls_state_st *state = &state_server;
1934 unsigned int sni_type;
1935 int rc, old_pool;
1936 uschar * dummy_errstr;
1937
1938 rc = gnutls_server_name_get(session, sni_name, &data_len, &sni_type, 0);
1939 if (rc != GNUTLS_E_SUCCESS)
1940   {
1941   DEBUG(D_tls) {
1942     if (rc == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
1943       debug_printf("TLS: no SNI presented in handshake.\n");
1944     else
1945       debug_printf("TLS failure: gnutls_server_name_get(): %s [%d]\n",
1946         gnutls_strerror(rc), rc);
1947     }
1948   return 0;
1949   }
1950
1951 if (sni_type != GNUTLS_NAME_DNS)
1952   {
1953   DEBUG(D_tls) debug_printf("TLS: ignoring SNI of unhandled type %u\n", sni_type);
1954   return 0;
1955   }
1956
1957 /* We now have a UTF-8 string in sni_name */
1958 old_pool = store_pool;
1959 store_pool = POOL_PERM;
1960 state->received_sni = string_copyn(US sni_name, data_len);
1961 store_pool = old_pool;
1962
1963 /* We set this one now so that variable expansions below will work */
1964 state->tlsp->sni = state->received_sni;
1965
1966 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", sni_name,
1967     state->trigger_sni_changes ? "" : " (unused for certificate selection)");
1968
1969 if (!state->trigger_sni_changes)
1970   return 0;
1971
1972 if ((rc = tls_expand_session_files(state, &dummy_errstr)) != OK)
1973   {
1974   /* If the setup of certs/etc failed before handshake, TLS would not have
1975   been offered.  The best we can do now is abort. */
1976   return GNUTLS_E_APPLICATION_ERROR_MIN;
1977   }
1978
1979 rc = tls_set_remaining_x509(state, &dummy_errstr);
1980 if (rc != OK) return GNUTLS_E_APPLICATION_ERROR_MIN;
1981
1982 return 0;
1983 }
1984
1985
1986
1987 #ifndef DISABLE_OCSP
1988
1989 static int
1990 server_ocsp_stapling_cb(gnutls_session_t session, void * ptr,
1991   gnutls_datum_t * ocsp_response)
1992 {
1993 int ret;
1994 DEBUG(D_tls) debug_printf("OCSP stapling callback: %s\n", US ptr);
1995
1996 if ((ret = gnutls_load_file(ptr, ocsp_response)) < 0)
1997   {
1998   DEBUG(D_tls) debug_printf("Failed to load ocsp stapling file %s\n",
1999                               CS ptr);
2000   tls_in.ocsp = OCSP_NOT_RESP;
2001   return GNUTLS_E_NO_CERTIFICATE_STATUS;
2002   }
2003
2004 tls_in.ocsp = OCSP_VFY_NOT_TRIED;
2005 return 0;
2006 }
2007
2008 #endif
2009
2010
2011 #ifndef DISABLE_EVENT
2012 /*
2013 We use this callback to get observability and detail-level control
2014 for an exim TLS connection (either direction), raising a tls:cert event
2015 for each cert in the chain presented by the peer.  Any event
2016 can deny verification.
2017
2018 Return 0 for the handshake to continue or non-zero to terminate.
2019 */
2020
2021 static int
2022 verify_cb(gnutls_session_t session)
2023 {
2024 const gnutls_datum_t * cert_list;
2025 unsigned int cert_list_size = 0;
2026 gnutls_x509_crt_t crt;
2027 int rc;
2028 uschar * yield;
2029 exim_gnutls_state_st * state = gnutls_session_get_ptr(session);
2030
2031 if ((cert_list = gnutls_certificate_get_peers(session, &cert_list_size)))
2032   while (cert_list_size--)
2033   {
2034   if ((rc = import_cert(&cert_list[cert_list_size], &crt)) != GNUTLS_E_SUCCESS)
2035     {
2036     DEBUG(D_tls) debug_printf("TLS: peer cert problem: depth %d: %s\n",
2037       cert_list_size, gnutls_strerror(rc));
2038     break;
2039     }
2040
2041   state->tlsp->peercert = crt;
2042   if ((yield = event_raise(state->event_action,
2043               US"tls:cert", string_sprintf("%d", cert_list_size))))
2044     {
2045     log_write(0, LOG_MAIN,
2046               "SSL verify denied by event-action: depth=%d: %s",
2047               cert_list_size, yield);
2048     return 1;                     /* reject */
2049     }
2050   state->tlsp->peercert = NULL;
2051   }
2052
2053 return 0;
2054 }
2055
2056 #endif
2057
2058
2059 static gstring *
2060 ddump(gnutls_datum_t * d)
2061 {
2062 gstring * g = string_get((d->size+1) * 2);
2063 uschar * s = d->data;
2064 for (unsigned i = d->size; i > 0; i--, s++)
2065   {
2066   g = string_catn(g, US "0123456789abcdef" + (*s >> 4), 1);
2067   g = string_catn(g, US "0123456789abcdef" + (*s & 0xf), 1);
2068   }
2069 return g;
2070 }
2071
2072 static void
2073 post_handshake_debug(exim_gnutls_state_st * state)
2074 {
2075 #ifdef SUPPORT_GNUTLS_SESS_DESC
2076 debug_printf("%s\n", gnutls_session_get_desc(state->session));
2077 #endif
2078 #ifdef SUPPORT_GNUTLS_KEYLOG
2079 # ifdef GNUTLS_TLS1_3
2080 if (gnutls_protocol_get_version(state->session) < GNUTLS_TLS1_3)
2081 #else
2082 if (TRUE)
2083 #endif
2084   {
2085   gnutls_datum_t c, s;
2086   gstring * gc, * gs;
2087   /* we only want the client random and the master secret */
2088   gnutls_session_get_random(state->session, &c, &s);
2089   gnutls_session_get_master_secret(state->session, &s);
2090   gc = ddump(&c);
2091   gs = ddump(&s);
2092   debug_printf("CLIENT_RANDOM %.*s %.*s\n", (int)gc->ptr, gc->s, (int)gs->ptr, gs->s);
2093   }
2094 else
2095   debug_printf("To get keying info for TLS1.3 is hard:\n"
2096     " set environment variable SSLKEYLOGFILE to a filename writable by uid exim\n"
2097     " add SSLKEYLOGFILE to keep_environment in the exim config\n"
2098     " run exim as root\n"
2099     " if using sudo, add SSLKEYLOGFILE to env_keep in /etc/sudoers\n");
2100 #endif
2101 }
2102
2103
2104 #ifdef EXPERIMENTAL_TLS_RESUME
2105 static int
2106 tls_server_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
2107   unsigned incoming, const gnutls_datum_t * msg)
2108 {
2109 DEBUG(D_tls) debug_printf("newticket cb\n");
2110 tls_in.resumption |= RESUME_CLIENT_REQUESTED;
2111 return 0;
2112 }
2113
2114 static void
2115 tls_server_resume_prehandshake(exim_gnutls_state_st * state)
2116 {
2117 /* Should the server offer session resumption? */
2118 tls_in.resumption = RESUME_SUPPORTED;
2119 if (verify_check_host(&tls_resumption_hosts) == OK)
2120   {
2121   int rc;
2122   /* GnuTLS appears to not do ticket overlap, but does emit a fresh ticket when
2123   an offered resumption is unacceptable.  We lose one resumption per ticket
2124   lifetime, and sessions cannot be indefinitely re-used.  There seems to be no
2125   way (3.6.7) of changing the default number of 2 TLS1.3 tickets issued, but at
2126   least they go out in a single packet. */
2127
2128   if (!(rc = gnutls_session_ticket_enable_server(state->session,
2129               &server_sessticket_key)))
2130     tls_in.resumption |= RESUME_SERVER_TICKET;
2131   else
2132     DEBUG(D_tls)
2133       debug_printf("enabling session tickets: %s\n", US gnutls_strerror(rc));
2134
2135   /* Try to tell if we see a ticket request */
2136   gnutls_handshake_set_hook_function(state->session,
2137     GNUTLS_HANDSHAKE_NEW_SESSION_TICKET, GNUTLS_HOOK_POST, tls_server_ticket_cb);
2138   }
2139 }
2140
2141 static void
2142 tls_server_resume_posthandshake(exim_gnutls_state_st * state)
2143 {
2144 if (gnutls_session_resumption_requested(state->session))
2145   {
2146   /* This tells us the client sent a full ticket.  We use a
2147   callback on session-ticket request, elsewhere, to tell
2148   if a client asked for a ticket. */
2149
2150   tls_in.resumption |= RESUME_CLIENT_SUGGESTED;
2151   DEBUG(D_tls) debug_printf("client requested resumption\n");
2152   }
2153 if (gnutls_session_is_resumed(state->session))
2154   {
2155   tls_in.resumption |= RESUME_USED;
2156   DEBUG(D_tls) debug_printf("Session resumed\n");
2157   }
2158 }
2159 #endif
2160 /* ------------------------------------------------------------------------ */
2161 /* Exported functions */
2162
2163
2164
2165
2166 /*************************************************
2167 *       Start a TLS session in a server          *
2168 *************************************************/
2169
2170 /* This is called when Exim is running as a server, after having received
2171 the STARTTLS command. It must respond to that command, and then negotiate
2172 a TLS session.
2173
2174 Arguments:
2175   require_ciphers  list of allowed ciphers or NULL
2176   errstr           pointer to error string
2177
2178 Returns:           OK on success
2179                    DEFER for errors before the start of the negotiation
2180                    FAIL for errors during the negotiation; the server can't
2181                      continue running.
2182 */
2183
2184 int
2185 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
2186 {
2187 int rc;
2188 exim_gnutls_state_st * state = NULL;
2189
2190 /* Check for previous activation */
2191 if (tls_in.active.sock >= 0)
2192   {
2193   tls_error(US"STARTTLS received after TLS started", US "", NULL, errstr);
2194   smtp_printf("554 Already in TLS\r\n", FALSE);
2195   return FAIL;
2196   }
2197
2198 /* Initialize the library. If it fails, it will already have logged the error
2199 and sent an SMTP response. */
2200
2201 DEBUG(D_tls) debug_printf("initialising GnuTLS as a server\n");
2202
2203 if ((rc = tls_init(NULL, tls_certificate, tls_privatekey,
2204     NULL, tls_verify_certificates, tls_crl,
2205     require_ciphers, &state, &tls_in, errstr)) != OK) return rc;
2206
2207 #ifdef EXPERIMENTAL_TLS_RESUME
2208 tls_server_resume_prehandshake(state);
2209 #endif
2210
2211 /* If this is a host for which certificate verification is mandatory or
2212 optional, set up appropriately. */
2213
2214 if (verify_check_host(&tls_verify_hosts) == OK)
2215   {
2216   DEBUG(D_tls)
2217     debug_printf("TLS: a client certificate will be required.\n");
2218   state->verify_requirement = VERIFY_REQUIRED;
2219   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
2220   }
2221 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2222   {
2223   DEBUG(D_tls)
2224     debug_printf("TLS: a client certificate will be requested but not required.\n");
2225   state->verify_requirement = VERIFY_OPTIONAL;
2226   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
2227   }
2228 else
2229   {
2230   DEBUG(D_tls)
2231     debug_printf("TLS: a client certificate will not be requested.\n");
2232   state->verify_requirement = VERIFY_NONE;
2233   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
2234   }
2235
2236 #ifndef DISABLE_EVENT
2237 if (event_action)
2238   {
2239   state->event_action = event_action;
2240   gnutls_session_set_ptr(state->session, state);
2241   gnutls_certificate_set_verify_function(state->x509_cred, verify_cb);
2242   }
2243 #endif
2244
2245 /* Register SNI handling; always, even if not in tls_certificate, so that the
2246 expansion variable $tls_sni is always available. */
2247
2248 gnutls_handshake_set_post_client_hello_function(state->session,
2249     exim_sni_handling_cb);
2250
2251 /* Set context and tell client to go ahead, except in the case of TLS startup
2252 on connection, where outputting anything now upsets the clients and tends to
2253 make them disconnect. We need to have an explicit fflush() here, to force out
2254 the response. Other smtp_printf() calls do not need it, because in non-TLS
2255 mode, the fflush() happens when smtp_getc() is called. */
2256
2257 if (!state->tlsp->on_connect)
2258   {
2259   smtp_printf("220 TLS go ahead\r\n", FALSE);
2260   fflush(smtp_out);
2261   }
2262
2263 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2264 that the GnuTLS library doesn't.
2265 From 3.1.0 there is gnutls_handshake_set_timeout() - but it requires you
2266 to set (and clear down afterwards) up a pull-timeout callback function that does
2267 a select, so we're no better off unless avoiding signals becomes an issue. */
2268
2269 gnutls_transport_set_ptr2(state->session,
2270     (gnutls_transport_ptr_t)(long) fileno(smtp_in),
2271     (gnutls_transport_ptr_t)(long) fileno(smtp_out));
2272 state->fd_in = fileno(smtp_in);
2273 state->fd_out = fileno(smtp_out);
2274
2275 sigalrm_seen = FALSE;
2276 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2277 do
2278   rc = gnutls_handshake(state->session);
2279 while (rc == GNUTLS_E_AGAIN ||  rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen);
2280 ALARM_CLR(0);
2281
2282 if (rc != GNUTLS_E_SUCCESS)
2283   {
2284   /* It seems that, except in the case of a timeout, we have to close the
2285   connection right here; otherwise if the other end is running OpenSSL it hangs
2286   until the server times out. */
2287
2288   if (sigalrm_seen)
2289     {
2290     tls_error(US"gnutls_handshake", US"timed out", NULL, errstr);
2291     gnutls_db_remove_session(state->session);
2292     }
2293   else
2294     {
2295     tls_error_gnu(US"gnutls_handshake", rc, NULL, errstr);
2296     (void) gnutls_alert_send_appropriate(state->session, rc);
2297     gnutls_deinit(state->session);
2298     gnutls_certificate_free_credentials(state->x509_cred);
2299     millisleep(500);
2300     shutdown(state->fd_out, SHUT_WR);
2301     for (int i = 1024; fgetc(smtp_in) != EOF && i > 0; ) i--;   /* drain skt */
2302     (void)fclose(smtp_out);
2303     (void)fclose(smtp_in);
2304     smtp_out = smtp_in = NULL;
2305     }
2306
2307   return FAIL;
2308   }
2309
2310 #ifdef EXPERIMENTAL_TLS_RESUME
2311 tls_server_resume_posthandshake(state);
2312 #endif
2313
2314 DEBUG(D_tls) post_handshake_debug(state);
2315
2316 /* Verify after the fact */
2317
2318 if (!verify_certificate(state, errstr))
2319   {
2320   if (state->verify_requirement != VERIFY_OPTIONAL)
2321     {
2322     (void) tls_error(US"certificate verification failed", *errstr, NULL, errstr);
2323     return FAIL;
2324     }
2325   DEBUG(D_tls)
2326     debug_printf("TLS: continuing on only because verification was optional, after: %s\n",
2327         *errstr);
2328   }
2329
2330 /* Sets various Exim expansion variables; always safe within server */
2331
2332 extract_exim_vars_from_tls_state(state);
2333
2334 /* TLS has been set up. Adjust the input functions to read via TLS,
2335 and initialize appropriately. */
2336
2337 state->xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2338
2339 receive_getc = tls_getc;
2340 receive_getbuf = tls_getbuf;
2341 receive_get_cache = tls_get_cache;
2342 receive_ungetc = tls_ungetc;
2343 receive_feof = tls_feof;
2344 receive_ferror = tls_ferror;
2345 receive_smtp_buffered = tls_smtp_buffered;
2346
2347 return OK;
2348 }
2349
2350
2351
2352
2353 static void
2354 tls_client_setup_hostname_checks(host_item * host, exim_gnutls_state_st * state,
2355   smtp_transport_options_block * ob)
2356 {
2357 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2358   {
2359   state->exp_tls_verify_cert_hostnames =
2360 #ifdef SUPPORT_I18N
2361     string_domain_utf8_to_alabel(host->name, NULL);
2362 #else
2363     host->name;
2364 #endif
2365   DEBUG(D_tls)
2366     debug_printf("TLS: server cert verification includes hostname: \"%s\".\n",
2367                     state->exp_tls_verify_cert_hostnames);
2368   }
2369 }
2370
2371
2372
2373
2374 #ifdef SUPPORT_DANE
2375 /* Given our list of RRs from the TLSA lookup, build a lookup block in
2376 GnuTLS-DANE's preferred format.  Hang it on the state str for later
2377 use in DANE verification.
2378
2379 We point at the dnsa data not copy it, so it must remain valid until
2380 after verification is done.*/
2381
2382 static BOOL
2383 dane_tlsa_load(exim_gnutls_state_st * state, dns_answer * dnsa)
2384 {
2385 dns_scan dnss;
2386 int i;
2387 const char **   dane_data;
2388 int *           dane_data_len;
2389
2390 i = 1;
2391 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2392      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2393     ) if (rr->type == T_TLSA) i++;
2394
2395 dane_data = store_get(i * sizeof(uschar *), FALSE);
2396 dane_data_len = store_get(i * sizeof(int), FALSE);
2397
2398 i = 0;
2399 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2400      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2401     ) if (rr->type == T_TLSA && rr->size > 3)
2402   {
2403   const uschar * p = rr->data;
2404 /*XXX need somehow to mark rr and its data as tainted.  Doues this mean copying it? */
2405   uint8_t usage = p[0], sel = p[1], type = p[2];
2406
2407   DEBUG(D_tls)
2408     debug_printf("TLSA: %d %d %d size %d\n", usage, sel, type, rr->size);
2409
2410   if (  (usage != DANESSL_USAGE_DANE_TA && usage != DANESSL_USAGE_DANE_EE)
2411      || (sel != 0 && sel != 1)
2412      )
2413     continue;
2414   switch(type)
2415     {
2416     case 0:     /* Full: cannot check at present */
2417                 break;
2418     case 1:     if (rr->size != 3 + 256/8) continue;    /* sha2-256 */
2419                 break;
2420     case 2:     if (rr->size != 3 + 512/8) continue;    /* sha2-512 */
2421                 break;
2422     default:    continue;
2423     }
2424
2425   tls_out.tlsa_usage |= 1<<usage;
2426   dane_data[i] = CS p;
2427   dane_data_len[i++] = rr->size;
2428   }
2429
2430 if (!i) return FALSE;
2431
2432 dane_data[i] = NULL;
2433 dane_data_len[i] = 0;
2434
2435 state->dane_data = (char * const *)dane_data;
2436 state->dane_data_len = dane_data_len;
2437 return TRUE;
2438 }
2439 #endif
2440
2441
2442
2443 #ifdef EXPERIMENTAL_TLS_RESUME
2444 /* On the client, get any stashed session for the given IP from hints db
2445 and apply it to the ssl-connection for attempted resumption.  Although
2446 there is a gnutls_session_ticket_enable_client() interface it is
2447 documented as unnecessary (as of 3.6.7) as "session tickets are emabled
2448 by deafult".  There seems to be no way to disable them, so even hosts not
2449 enabled by the transport option will be sent a ticket request.  We will
2450 however avoid storing and retrieving session information. */
2451
2452 static void
2453 tls_retrieve_session(tls_support * tlsp, gnutls_session_t session,
2454   host_item * host, smtp_transport_options_block * ob)
2455 {
2456 tlsp->resumption = RESUME_SUPPORTED;
2457 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
2458   {
2459   dbdata_tls_session * dt;
2460   int len, rc;
2461   open_db dbblock, * dbm_file;
2462
2463   DEBUG(D_tls)
2464     debug_printf("check for resumable session for %s\n", host->address);
2465   tlsp->host_resumable = TRUE;
2466   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
2467   if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
2468     {
2469     /* Key for the db is the IP.  We'd like to filter the retrieved session
2470     for ticket advisory expiry, but 3.6.1 seems to give no access to that */
2471
2472     if ((dt = dbfn_read_with_length(dbm_file, host->address, &len)))
2473       if (!(rc = gnutls_session_set_data(session,
2474                     CUS dt->session, (size_t)len - sizeof(dbdata_tls_session))))
2475         {
2476         DEBUG(D_tls) debug_printf("good session\n");
2477         tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
2478         }
2479       else DEBUG(D_tls) debug_printf("setting session resumption data: %s\n",
2480             US gnutls_strerror(rc));
2481     dbfn_close(dbm_file);
2482     }
2483   }
2484 }
2485
2486
2487 static void
2488 tls_save_session(tls_support * tlsp, gnutls_session_t session, const host_item * host)
2489 {
2490 /* TLS 1.2 - we get both the callback and the direct posthandshake call,
2491 but this flag is not set until the second.  TLS 1.3 it's the other way about.
2492 Keep both calls as the session data cannot be extracted before handshake
2493 completes. */
2494
2495 if (gnutls_session_get_flags(session) & GNUTLS_SFLAGS_SESSION_TICKET)
2496   {
2497   gnutls_datum_t tkt;
2498   int rc;
2499
2500   DEBUG(D_tls) debug_printf("server offered session ticket\n");
2501   tlsp->ticket_received = TRUE;
2502   tlsp->resumption |= RESUME_SERVER_TICKET;
2503
2504   if (tlsp->host_resumable)
2505     if (!(rc = gnutls_session_get_data2(session, &tkt)))
2506       {
2507       open_db dbblock, * dbm_file;
2508       int dlen = sizeof(dbdata_tls_session) + tkt.size;
2509       dbdata_tls_session * dt = store_get(dlen, TRUE);
2510
2511       DEBUG(D_tls) debug_printf("session data size %u\n", (unsigned)tkt.size);
2512       memcpy(dt->session, tkt.data, tkt.size);
2513       gnutls_free(tkt.data);
2514
2515       if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
2516         {
2517         /* key for the db is the IP */
2518         dbfn_delete(dbm_file, host->address);
2519         dbfn_write(dbm_file, host->address, dt, dlen);
2520         dbfn_close(dbm_file);
2521
2522         DEBUG(D_tls)
2523           debug_printf("wrote session db (len %u)\n", (unsigned)dlen);
2524         }
2525       }
2526     else DEBUG(D_tls)
2527       debug_printf("extract session data: %s\n", US gnutls_strerror(rc));
2528   }
2529 }
2530
2531
2532 /* With a TLS1.3 session, the ticket(s) are not seen until
2533 the first data read is attempted.  And there's often two of them.
2534 Pick them up with this callback.  We are also called for 1.2
2535 but we do nothing.
2536 */
2537 static int
2538 tls_client_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
2539   unsigned incoming, const gnutls_datum_t * msg)
2540 {
2541 exim_gnutls_state_st * state = gnutls_session_get_ptr(sess);
2542 tls_support * tlsp = state->tlsp;
2543
2544 DEBUG(D_tls) debug_printf("newticket cb\n");
2545
2546 if (!tlsp->ticket_received)
2547   tls_save_session(tlsp, sess, state->host);
2548 return 0;
2549 }
2550
2551
2552 static void
2553 tls_client_resume_prehandshake(exim_gnutls_state_st * state,
2554   tls_support * tlsp, host_item * host,
2555   smtp_transport_options_block * ob)
2556 {
2557 gnutls_session_set_ptr(state->session, state);
2558 gnutls_handshake_set_hook_function(state->session,
2559   GNUTLS_HANDSHAKE_NEW_SESSION_TICKET, GNUTLS_HOOK_POST, tls_client_ticket_cb);
2560
2561 tls_retrieve_session(tlsp, state->session, host, ob);
2562 }
2563
2564 static void
2565 tls_client_resume_posthandshake(exim_gnutls_state_st * state,
2566   tls_support * tlsp, host_item * host)
2567 {
2568 if (gnutls_session_is_resumed(state->session))
2569   {
2570   DEBUG(D_tls) debug_printf("Session resumed\n");
2571   tlsp->resumption |= RESUME_USED;
2572   }
2573
2574 tls_save_session(tlsp, state->session, host);
2575 }
2576 #endif  /* EXPERIMENTAL_TLS_RESUME */
2577
2578
2579 /*************************************************
2580 *    Start a TLS session in a client             *
2581 *************************************************/
2582
2583 /* Called from the smtp transport after STARTTLS has been accepted.
2584
2585 Arguments:
2586   cctx          connection context
2587   conn_args     connection details
2588   cookie        datum for randomness (not used)
2589   tlsp          record details of channel configuration here; must be non-NULL
2590   errstr        error string pointer
2591
2592 Returns:        TRUE for success with TLS session context set in smtp context,
2593                 FALSE on error
2594 */
2595
2596 BOOL
2597 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
2598   void * cookie ARG_UNUSED,
2599   tls_support * tlsp, uschar ** errstr)
2600 {
2601 host_item * host = conn_args->host;          /* for msgs and option-tests */
2602 transport_instance * tb = conn_args->tblock; /* always smtp or NULL */
2603 smtp_transport_options_block * ob = tb
2604   ? (smtp_transport_options_block *)tb->options_block
2605   : &smtp_transport_option_defaults;
2606 int rc;
2607 exim_gnutls_state_st * state = NULL;
2608 uschar * cipher_list = NULL;
2609
2610 #ifndef DISABLE_OCSP
2611 BOOL require_ocsp =
2612   verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
2613 BOOL request_ocsp = require_ocsp ? TRUE
2614   : verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
2615 #endif
2616
2617 DEBUG(D_tls) debug_printf("initialising GnuTLS as a client on fd %d\n", cctx->sock);
2618
2619 #ifdef SUPPORT_DANE
2620 /* If dane is flagged, have either request or require dane for this host, and
2621 a TLSA record found.  Therefore, dane verify required.  Which implies cert must
2622 be requested and supplied, dane verify must pass, and cert verify irrelevant
2623 (incl.  hostnames), and (caller handled) require_tls */
2624
2625 if (conn_args->dane && ob->dane_require_tls_ciphers)
2626   {
2627   /* not using expand_check_tlsvar because not yet in state */
2628   if (!expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2629       &cipher_list, errstr))
2630     return FALSE;
2631   cipher_list = cipher_list && *cipher_list
2632     ? ob->dane_require_tls_ciphers : ob->tls_require_ciphers;
2633   }
2634 #endif
2635
2636 if (!cipher_list)
2637   cipher_list = ob->tls_require_ciphers;
2638
2639 if (tls_init(host, ob->tls_certificate, ob->tls_privatekey,
2640     ob->tls_sni, ob->tls_verify_certificates, ob->tls_crl,
2641     cipher_list, &state, tlsp, errstr) != OK)
2642   return FALSE;
2643
2644   {
2645   int dh_min_bits = ob->tls_dh_min_bits;
2646   if (dh_min_bits < EXIM_CLIENT_DH_MIN_MIN_BITS)
2647     {
2648     DEBUG(D_tls)
2649       debug_printf("WARNING: tls_dh_min_bits far too low,"
2650                     " clamping %d up to %d\n",
2651           dh_min_bits, EXIM_CLIENT_DH_MIN_MIN_BITS);
2652     dh_min_bits = EXIM_CLIENT_DH_MIN_MIN_BITS;
2653     }
2654
2655   DEBUG(D_tls) debug_printf("Setting D-H prime minimum"
2656                     " acceptable bits to %d\n",
2657       dh_min_bits);
2658   gnutls_dh_set_prime_bits(state->session, dh_min_bits);
2659   }
2660
2661 /* Stick to the old behaviour for compatibility if tls_verify_certificates is
2662 set but both tls_verify_hosts and tls_try_verify_hosts are unset. Check only
2663 the specified host patterns if one of them is defined */
2664
2665 #ifdef SUPPORT_DANE
2666 if (conn_args->dane && dane_tlsa_load(state, &conn_args->tlsa_dnsa))
2667   {
2668   DEBUG(D_tls)
2669     debug_printf("TLS: server certificate DANE required.\n");
2670   state->verify_requirement = VERIFY_DANE;
2671   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
2672   }
2673 else
2674 #endif
2675     if (  (  state->exp_tls_verify_certificates
2676           && !ob->tls_verify_hosts
2677           && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2678           )
2679         || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2680        )
2681   {
2682   tls_client_setup_hostname_checks(host, state, ob);
2683   DEBUG(D_tls)
2684     debug_printf("TLS: server certificate verification required.\n");
2685   state->verify_requirement = VERIFY_REQUIRED;
2686   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
2687   }
2688 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2689   {
2690   tls_client_setup_hostname_checks(host, state, ob);
2691   DEBUG(D_tls)
2692     debug_printf("TLS: server certificate verification optional.\n");
2693   state->verify_requirement = VERIFY_OPTIONAL;
2694   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
2695   }
2696 else
2697   {
2698   DEBUG(D_tls)
2699     debug_printf("TLS: server certificate verification not required.\n");
2700   state->verify_requirement = VERIFY_NONE;
2701   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
2702   }
2703
2704 #ifndef DISABLE_OCSP
2705                         /* supported since GnuTLS 3.1.3 */
2706 if (request_ocsp)
2707   {
2708   DEBUG(D_tls) debug_printf("TLS: will request OCSP stapling\n");
2709   if ((rc = gnutls_ocsp_status_request_enable_client(state->session,
2710                     NULL, 0, NULL)) != OK)
2711     {
2712     tls_error_gnu(US"cert-status-req", rc, state->host, errstr);
2713     return FALSE;
2714     }
2715   tlsp->ocsp = OCSP_NOT_RESP;
2716   }
2717 #endif
2718
2719 #ifdef EXPERIMENTAL_TLS_RESUME
2720 tls_client_resume_prehandshake(state, tlsp, host, ob);
2721 #endif
2722
2723 #ifndef DISABLE_EVENT
2724 if (tb && tb->event_action)
2725   {
2726   state->event_action = tb->event_action;
2727   gnutls_session_set_ptr(state->session, state);
2728   gnutls_certificate_set_verify_function(state->x509_cred, verify_cb);
2729   }
2730 #endif
2731
2732 gnutls_transport_set_ptr(state->session, (gnutls_transport_ptr_t)(long) cctx->sock);
2733 state->fd_in = cctx->sock;
2734 state->fd_out = cctx->sock;
2735
2736 DEBUG(D_tls) debug_printf("about to gnutls_handshake\n");
2737 /* There doesn't seem to be a built-in timeout on connection. */
2738
2739 sigalrm_seen = FALSE;
2740 ALARM(ob->command_timeout);
2741 do
2742   rc = gnutls_handshake(state->session);
2743 while (rc == GNUTLS_E_AGAIN || rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen);
2744 ALARM_CLR(0);
2745
2746 if (rc != GNUTLS_E_SUCCESS)
2747   {
2748   if (sigalrm_seen)
2749     {
2750     gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_USER_CANCELED);
2751     tls_error(US"gnutls_handshake", US"timed out", state->host, errstr);
2752     }
2753   else
2754     tls_error_gnu(US"gnutls_handshake", rc, state->host, errstr);
2755   return FALSE;
2756   }
2757
2758 DEBUG(D_tls) post_handshake_debug(state);
2759
2760 /* Verify late */
2761
2762 if (!verify_certificate(state, errstr))
2763   {
2764   tls_error(US"certificate verification failed", *errstr, state->host, errstr);
2765   return FALSE;
2766   }
2767
2768 #ifndef DISABLE_OCSP
2769 if (request_ocsp)
2770   {
2771   DEBUG(D_tls)
2772     {
2773     gnutls_datum_t stapling;
2774     gnutls_ocsp_resp_t resp;
2775     gnutls_datum_t printed;
2776     if (  (rc= gnutls_ocsp_status_request_get(state->session, &stapling)) == 0
2777        && (rc= gnutls_ocsp_resp_init(&resp)) == 0
2778        && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
2779        && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &printed)) == 0
2780        )
2781       {
2782       debug_printf("%.4096s", printed.data);
2783       gnutls_free(printed.data);
2784       }
2785     else
2786       (void) tls_error_gnu(US"ocsp decode", rc, state->host, errstr);
2787     }
2788
2789   if (gnutls_ocsp_status_request_is_checked(state->session, 0) == 0)
2790     {
2791     tlsp->ocsp = OCSP_FAILED;
2792     tls_error(US"certificate status check failed", NULL, state->host, errstr);
2793     if (require_ocsp)
2794       return FALSE;
2795     }
2796   else
2797     {
2798     DEBUG(D_tls) debug_printf("Passed OCSP checking\n");
2799     tlsp->ocsp = OCSP_VFIED;
2800     }
2801   }
2802 #endif
2803
2804 #ifdef EXPERIMENTAL_TLS_RESUME
2805 tls_client_resume_posthandshake(state, tlsp, host);
2806 #endif
2807
2808 /* Sets various Exim expansion variables; may need to adjust for ACL callouts */
2809
2810 extract_exim_vars_from_tls_state(state);
2811
2812 cctx->tls_ctx = state;
2813 return TRUE;
2814 }
2815
2816
2817
2818
2819 /*************************************************
2820 *         Close down a TLS session               *
2821 *************************************************/
2822
2823 /* This is also called from within a delivery subprocess forked from the
2824 daemon, to shut down the TLS library, without actually doing a shutdown (which
2825 would tamper with the TLS session in the parent process).
2826
2827 Arguments:
2828   ct_ctx        client context pointer, or NULL for the one global server context
2829   shutdown      1 if TLS close-alert is to be sent,
2830                 2 if also response to be waited for
2831
2832 Returns:     nothing
2833 */
2834
2835 void
2836 tls_close(void * ct_ctx, int shutdown)
2837 {
2838 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
2839
2840 if (!state->tlsp || state->tlsp->active.sock < 0) return;  /* TLS was not active */
2841
2842 if (shutdown)
2843   {
2844   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
2845     shutdown > 1 ? " (with response-wait)" : "");
2846
2847   ALARM(2);
2848   gnutls_bye(state->session, shutdown > 1 ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
2849   ALARM_CLR(0);
2850   }
2851
2852 gnutls_deinit(state->session);
2853 gnutls_certificate_free_credentials(state->x509_cred);
2854
2855
2856 state->tlsp->active.sock = -1;
2857 state->tlsp->active.tls_ctx = NULL;
2858 if (state->xfer_buffer) store_free(state->xfer_buffer);
2859 memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
2860 }
2861
2862
2863
2864
2865 static BOOL
2866 tls_refill(unsigned lim)
2867 {
2868 exim_gnutls_state_st * state = &state_server;
2869 ssize_t inbytes;
2870
2871 DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%p, %p, %u)\n",
2872   state->session, state->xfer_buffer, ssl_xfer_buffer_size);
2873
2874 sigalrm_seen = FALSE;
2875 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2876
2877 do
2878   inbytes = gnutls_record_recv(state->session, state->xfer_buffer,
2879     MIN(ssl_xfer_buffer_size, lim));
2880 while (inbytes == GNUTLS_E_AGAIN);
2881
2882 if (smtp_receive_timeout > 0) ALARM_CLR(0);
2883
2884 if (had_command_timeout)                /* set by signal handler */
2885   smtp_command_timeout_exit();          /* does not return */
2886 if (had_command_sigterm)
2887   smtp_command_sigterm_exit();
2888 if (had_data_timeout)
2889   smtp_data_timeout_exit();
2890 if (had_data_sigint)
2891   smtp_data_sigint_exit();
2892
2893 /* Timeouts do not get this far.  A zero-byte return appears to mean that the
2894 TLS session has been closed down, not that the socket itself has been closed
2895 down. Revert to non-TLS handling. */
2896
2897 if (sigalrm_seen)
2898   {
2899   DEBUG(D_tls) debug_printf("Got tls read timeout\n");
2900   state->xfer_error = TRUE;
2901   return FALSE;
2902   }
2903
2904 else if (inbytes == 0)
2905   {
2906   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
2907
2908   receive_getc = smtp_getc;
2909   receive_getbuf = smtp_getbuf;
2910   receive_get_cache = smtp_get_cache;
2911   receive_ungetc = smtp_ungetc;
2912   receive_feof = smtp_feof;
2913   receive_ferror = smtp_ferror;
2914   receive_smtp_buffered = smtp_buffered;
2915
2916   gnutls_deinit(state->session);
2917   gnutls_certificate_free_credentials(state->x509_cred);
2918
2919   state->session = NULL;
2920   state->tlsp->active.sock = -1;
2921   state->tlsp->active.tls_ctx = NULL;
2922   state->tlsp->bits = 0;
2923   state->tlsp->certificate_verified = FALSE;
2924   tls_channelbinding_b64 = NULL;
2925   state->tlsp->cipher = NULL;
2926   state->tlsp->peercert = NULL;
2927   state->tlsp->peerdn = NULL;
2928
2929   return FALSE;
2930   }
2931
2932 /* Handle genuine errors */
2933
2934 else if (inbytes < 0)
2935   {
2936   DEBUG(D_tls) debug_printf("%s: err from gnutls_record_recv\n", __FUNCTION__);
2937   record_io_error(state, (int) inbytes, US"recv", NULL);
2938   state->xfer_error = TRUE;
2939   return FALSE;
2940   }
2941 #ifndef DISABLE_DKIM
2942 dkim_exim_verify_feed(state->xfer_buffer, inbytes);
2943 #endif
2944 state->xfer_buffer_hwm = (int) inbytes;
2945 state->xfer_buffer_lwm = 0;
2946 return TRUE;
2947 }
2948
2949 /*************************************************
2950 *            TLS version of getc                 *
2951 *************************************************/
2952
2953 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
2954 it refills the buffer via the GnuTLS reading function.
2955 Only used by the server-side TLS.
2956
2957 This feeds DKIM and should be used for all message-body reads.
2958
2959 Arguments:  lim         Maximum amount to read/buffer
2960 Returns:    the next character or EOF
2961 */
2962
2963 int
2964 tls_getc(unsigned lim)
2965 {
2966 exim_gnutls_state_st * state = &state_server;
2967
2968 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
2969   if (!tls_refill(lim))
2970     return state->xfer_error ? EOF : smtp_getc(lim);
2971
2972 /* Something in the buffer; return next uschar */
2973
2974 return state->xfer_buffer[state->xfer_buffer_lwm++];
2975 }
2976
2977 uschar *
2978 tls_getbuf(unsigned * len)
2979 {
2980 exim_gnutls_state_st * state = &state_server;
2981 unsigned size;
2982 uschar * buf;
2983
2984 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
2985   if (!tls_refill(*len))
2986     {
2987     if (!state->xfer_error) return smtp_getbuf(len);
2988     *len = 0;
2989     return NULL;
2990     }
2991
2992 if ((size = state->xfer_buffer_hwm - state->xfer_buffer_lwm) > *len)
2993   size = *len;
2994 buf = &state->xfer_buffer[state->xfer_buffer_lwm];
2995 state->xfer_buffer_lwm += size;
2996 *len = size;
2997 return buf;
2998 }
2999
3000
3001 void
3002 tls_get_cache()
3003 {
3004 #ifndef DISABLE_DKIM
3005 exim_gnutls_state_st * state = &state_server;
3006 int n = state->xfer_buffer_hwm - state->xfer_buffer_lwm;
3007 if (n > 0)
3008   dkim_exim_verify_feed(state->xfer_buffer+state->xfer_buffer_lwm, n);
3009 #endif
3010 }
3011
3012
3013 BOOL
3014 tls_could_read(void)
3015 {
3016 return state_server.xfer_buffer_lwm < state_server.xfer_buffer_hwm
3017  || gnutls_record_check_pending(state_server.session) > 0;
3018 }
3019
3020
3021
3022
3023 /*************************************************
3024 *          Read bytes from TLS channel           *
3025 *************************************************/
3026
3027 /* This does not feed DKIM, so if the caller uses this for reading message body,
3028 then the caller must feed DKIM.
3029
3030 Arguments:
3031   ct_ctx    client context pointer, or NULL for the one global server context
3032   buff      buffer of data
3033   len       size of buffer
3034
3035 Returns:    the number of bytes read
3036             -1 after a failed read, including EOF
3037 */
3038
3039 int
3040 tls_read(void * ct_ctx, uschar *buff, size_t len)
3041 {
3042 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3043 ssize_t inbytes;
3044
3045 if (len > INT_MAX)
3046   len = INT_MAX;
3047
3048 if (state->xfer_buffer_lwm < state->xfer_buffer_hwm)
3049   DEBUG(D_tls)
3050     debug_printf("*** PROBABLY A BUG *** " \
3051         "tls_read() called with data in the tls_getc() buffer, %d ignored\n",
3052         state->xfer_buffer_hwm - state->xfer_buffer_lwm);
3053
3054 DEBUG(D_tls)
3055   debug_printf("Calling gnutls_record_recv(%p, %p, " SIZE_T_FMT ")\n",
3056       state->session, buff, len);
3057
3058 do
3059   inbytes = gnutls_record_recv(state->session, buff, len);
3060 while (inbytes == GNUTLS_E_AGAIN);
3061
3062 if (inbytes > 0) return inbytes;
3063 if (inbytes == 0)
3064   {
3065   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
3066   }
3067 else
3068   {
3069   DEBUG(D_tls) debug_printf("%s: err from gnutls_record_recv\n", __FUNCTION__);
3070   record_io_error(state, (int)inbytes, US"recv", NULL);
3071   }
3072
3073 return -1;
3074 }
3075
3076
3077
3078
3079 /*************************************************
3080 *         Write bytes down TLS channel           *
3081 *************************************************/
3082
3083 /*
3084 Arguments:
3085   ct_ctx    client context pointer, or NULL for the one global server context
3086   buff      buffer of data
3087   len       number of bytes
3088   more      more data expected soon
3089
3090 Returns:    the number of bytes after a successful write,
3091             -1 after a failed write
3092 */
3093
3094 int
3095 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
3096 {
3097 ssize_t outbytes;
3098 size_t left = len;
3099 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3100 #ifdef SUPPORT_CORK
3101 static BOOL corked = FALSE;
3102
3103 if (more && !corked) gnutls_record_cork(state->session);
3104 #endif
3105
3106 DEBUG(D_tls) debug_printf("%s(%p, " SIZE_T_FMT "%s)\n", __FUNCTION__,
3107   buff, left, more ? ", more" : "");
3108
3109 while (left > 0)
3110   {
3111   DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %p, " SIZE_T_FMT ")\n",
3112       buff, left);
3113
3114   do
3115     outbytes = gnutls_record_send(state->session, buff, left);
3116   while (outbytes == GNUTLS_E_AGAIN);
3117
3118   DEBUG(D_tls) debug_printf("outbytes=" SSIZE_T_FMT "\n", outbytes);
3119   if (outbytes < 0)
3120     {
3121     DEBUG(D_tls) debug_printf("%s: gnutls_record_send err\n", __FUNCTION__);
3122     record_io_error(state, outbytes, US"send", NULL);
3123     return -1;
3124     }
3125   if (outbytes == 0)
3126     {
3127     record_io_error(state, 0, US"send", US"TLS channel closed on write");
3128     return -1;
3129     }
3130
3131   left -= outbytes;
3132   buff += outbytes;
3133   }
3134
3135 if (len > INT_MAX)
3136   {
3137   DEBUG(D_tls)
3138     debug_printf("Whoops!  Wrote more bytes (" SIZE_T_FMT ") than INT_MAX\n",
3139         len);
3140   len = INT_MAX;
3141   }
3142
3143 #ifdef SUPPORT_CORK
3144 if (more != corked)
3145   {
3146   if (!more) (void) gnutls_record_uncork(state->session, 0);
3147   corked = more;
3148   }
3149 #endif
3150
3151 return (int) len;
3152 }
3153
3154
3155
3156
3157 /*************************************************
3158 *            Random number generation            *
3159 *************************************************/
3160
3161 /* Pseudo-random number generation.  The result is not expected to be
3162 cryptographically strong but not so weak that someone will shoot themselves
3163 in the foot using it as a nonce in input in some email header scheme or
3164 whatever weirdness they'll twist this into.  The result should handle fork()
3165 and avoid repeating sequences.  OpenSSL handles that for us.
3166
3167 Arguments:
3168   max       range maximum
3169 Returns     a random number in range [0, max-1]
3170 */
3171
3172 #ifdef HAVE_GNUTLS_RND
3173 int
3174 vaguely_random_number(int max)
3175 {
3176 unsigned int r;
3177 int i, needed_len;
3178 uschar smallbuf[sizeof(r)];
3179
3180 if (max <= 1)
3181   return 0;
3182
3183 needed_len = sizeof(r);
3184 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3185 asked for a number less than 10. */
3186
3187 for (r = max, i = 0; r; ++i)
3188   r >>= 1;
3189 i = (i + 7) / 8;
3190 if (i < needed_len)
3191   needed_len = i;
3192
3193 i = gnutls_rnd(GNUTLS_RND_NONCE, smallbuf, needed_len);
3194 if (i < 0)
3195   {
3196   DEBUG(D_all) debug_printf("gnutls_rnd() failed, using fallback.\n");
3197   return vaguely_random_number_fallback(max);
3198   }
3199 r = 0;
3200 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
3201   r = r * 256 + *p;
3202
3203 /* We don't particularly care about weighted results; if someone wants
3204  * smooth distribution and cares enough then they should submit a patch then. */
3205 return r % max;
3206 }
3207 #else /* HAVE_GNUTLS_RND */
3208 int
3209 vaguely_random_number(int max)
3210 {
3211   return vaguely_random_number_fallback(max);
3212 }
3213 #endif /* HAVE_GNUTLS_RND */
3214
3215
3216
3217
3218 /*************************************************
3219 *  Let tls_require_ciphers be checked at startup *
3220 *************************************************/
3221
3222 /* The tls_require_ciphers option, if set, must be something which the
3223 library can parse.
3224
3225 Returns:     NULL on success, or error message
3226 */
3227
3228 uschar *
3229 tls_validate_require_cipher(void)
3230 {
3231 int rc;
3232 uschar *expciphers = NULL;
3233 gnutls_priority_t priority_cache;
3234 const char *errpos;
3235 uschar * dummy_errstr;
3236
3237 #define validate_check_rc(Label) do { \
3238   if (rc != GNUTLS_E_SUCCESS) { if (exim_gnutls_base_init_done) gnutls_global_deinit(); \
3239   return string_sprintf("%s failed: %s", (Label), gnutls_strerror(rc)); } } while (0)
3240 #define return_deinit(Label) do { gnutls_global_deinit(); return (Label); } while (0)
3241
3242 if (exim_gnutls_base_init_done)
3243   log_write(0, LOG_MAIN|LOG_PANIC,
3244       "already initialised GnuTLS, Exim developer bug");
3245
3246 #ifdef HAVE_GNUTLS_PKCS11
3247 if (!gnutls_allow_auto_pkcs11)
3248   {
3249   rc = gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_MANUAL, NULL);
3250   validate_check_rc(US"gnutls_pkcs11_init");
3251   }
3252 #endif
3253 rc = gnutls_global_init();
3254 validate_check_rc(US"gnutls_global_init()");
3255 exim_gnutls_base_init_done = TRUE;
3256
3257 if (!(tls_require_ciphers && *tls_require_ciphers))
3258   return_deinit(NULL);
3259
3260 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3261                   &dummy_errstr))
3262   return_deinit(US"failed to expand tls_require_ciphers");
3263
3264 if (!(expciphers && *expciphers))
3265   return_deinit(NULL);
3266
3267 DEBUG(D_tls)
3268   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3269
3270 rc = gnutls_priority_init(&priority_cache, CS expciphers, &errpos);
3271 validate_check_rc(string_sprintf(
3272       "gnutls_priority_init(%s) failed at offset %ld, \"%.8s..\"",
3273       expciphers, errpos - CS expciphers, errpos));
3274
3275 #undef return_deinit
3276 #undef validate_check_rc
3277 gnutls_global_deinit();
3278
3279 return NULL;
3280 }
3281
3282
3283
3284
3285 /*************************************************
3286 *         Report the library versions.           *
3287 *************************************************/
3288
3289 /* See a description in tls-openssl.c for an explanation of why this exists.
3290
3291 Arguments:   a FILE* to print the results to
3292 Returns:     nothing
3293 */
3294
3295 void
3296 tls_version_report(FILE *f)
3297 {
3298 fprintf(f, "Library version: GnuTLS: Compile: %s\n"
3299            "                         Runtime: %s\n",
3300            LIBGNUTLS_VERSION,
3301            gnutls_check_version(NULL));
3302 }
3303
3304 #endif  /*!MACRO_PREDEF*/
3305 /* vi: aw ai sw=2
3306 */
3307 /* End of tls-gnu.c */