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