fix TLS SNI segfault case
[exim.git] / src / src / tls-gnu.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2012 */
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 Mavroyanopoulos.  The revamp is partially a rewrite, partially cut&paste as
17 appropriate.
18
19 APIs current as of GnuTLS 2.12.18; note that the GnuTLS manual is for GnuTLS 3,
20 which is not widely deployed by OS vendors.  Will note issues below, which may
21 assist in updating the code in the future.  Another sources of hints is
22 mod_gnutls for Apache (SNI callback registration and handling).
23
24 Keeping client and server variables more split than before and is currently
25 the norm, in anticipation of TLS in ACL callouts.
26
27 I wanted to switch to gnutls_certificate_set_verify_function() so that
28 certificate rejection could happen during handshake where it belongs, rather
29 than being dropped afterwards, but that was introduced in 2.10.0 and Debian
30 (6.0.5) is still on 2.8.6.  So for now we have to stick with sub-par behaviour.
31
32 (I wasn't looking for libraries quite that old, when updating to get rid of
33 compiler warnings of deprecated APIs.  If it turns out that a lot of the rest
34 require current GnuTLS, then we'll drop support for the ancient libraries).
35 */
36
37 #include <gnutls/gnutls.h>
38 /* needed for cert checks in verification and DN extraction: */
39 #include <gnutls/x509.h>
40 /* man-page is incorrect, gnutls_rnd() is not in gnutls.h: */
41 #include <gnutls/crypto.h>
42
43 /* GnuTLS 2 vs 3
44
45 GnuTLS 3 only:
46   gnutls_global_set_audit_log_function()
47
48 Changes:
49   gnutls_certificate_verify_peers2(): is new, drop the 2 for old version
50 */
51
52 /* Local static variables for GnuTLS */
53
54 /* Values for verify_requirement */
55
56 enum peer_verify_requirement { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED };
57
58 /* This holds most state for server or client; with this, we can set up an
59 outbound TLS-enabled connection in an ACL callout, while not stomping all
60 over the TLS variables available for expansion.
61
62 Some of these correspond to variables in globals.c; those variables will
63 be set to point to content in one of these instances, as appropriate for
64 the stage of the process lifetime.
65
66 Not handled here: globals tls_active, tls_bits, tls_cipher, tls_peerdn,
67 tls_certificate_verified, tls_channelbinding_b64, tls_sni.
68 */
69
70 typedef struct exim_gnutls_state {
71   gnutls_session_t session;
72   gnutls_certificate_credentials_t x509_cred;
73   gnutls_priority_t priority_cache;
74   enum peer_verify_requirement verify_requirement;
75   int fd_in;
76   int fd_out;
77   BOOL peer_cert_verified;
78   BOOL trigger_sni_changes;
79   const struct host_item *host;
80   uschar *peerdn;
81   uschar *received_sni;
82
83   const uschar *tls_certificate;
84   const uschar *tls_privatekey;
85   const uschar *tls_sni; /* client send only, not received */
86   const uschar *tls_verify_certificates;
87   const uschar *tls_crl;
88   const uschar *tls_require_ciphers;
89   uschar *exp_tls_certificate;
90   uschar *exp_tls_privatekey;
91   uschar *exp_tls_sni;
92   uschar *exp_tls_verify_certificates;
93   uschar *exp_tls_crl;
94   uschar *exp_tls_require_ciphers;
95
96   uschar *xfer_buffer;
97   int xfer_buffer_lwm;
98   int xfer_buffer_hwm;
99   int xfer_eof;
100   int xfer_error;
101
102   uschar cipherbuf[256];
103 } exim_gnutls_state_st;
104
105 static const exim_gnutls_state_st exim_gnutls_state_init = {
106   NULL, NULL, NULL, VERIFY_NONE, -1, -1, FALSE, FALSE,
107   NULL, NULL, NULL,
108   NULL, NULL, NULL, NULL, NULL, NULL,
109   NULL, NULL, NULL, NULL, NULL, NULL,
110   NULL, 0, 0, 0, 0,
111   ""
112 };
113
114 /* Not only do we have our own APIs which don't pass around state, assuming
115 it's held in globals, GnuTLS doesn't appear to let us register callback data
116 for callbacks, or as part of the session, so we have to keep a "this is the
117 context we're currently dealing with" pointer and rely upon being
118 single-threaded to keep from processing data on an inbound TLS connection while
119 talking to another TLS connection for an outbound check.  This does mean that
120 there's no way for heart-beats to be responded to, for the duration of the
121 second connection. */
122
123 static exim_gnutls_state_st state_server, state_client;
124 static exim_gnutls_state_st *current_global_tls_state;
125
126 /* dh_params are initialised once within the lifetime of a process using TLS;
127 if we used TLS in a long-lived daemon, we'd have to reconsider this.  But we
128 don't want to repeat this. */
129
130 static gnutls_dh_params_t dh_server_params = NULL;
131
132 /* No idea how this value was chosen; preserving it.  Default is 3600. */
133
134 static const int ssl_session_timeout = 200;
135
136 static const char * const exim_default_gnutls_priority = "NORMAL";
137
138 /* Guard library core initialisation */
139
140 static BOOL exim_gnutls_base_init_done = FALSE;
141
142
143 /* ------------------------------------------------------------------------ */
144 /* macros */
145
146 #define MAX_HOST_LEN 255
147
148 /* Set this to control gnutls_global_set_log_level(); values 0 to 9 will setup
149 the library logging; a value less than 0 disables the calls to set up logging
150 callbacks. */
151 #define EXIM_GNUTLS_LIBRARY_LOG_LEVEL -1
152
153 #define EXIM_CLIENT_DH_MIN_BITS 1024
154
155 /* With GnuTLS 2.12.x+ we have gnutls_sec_param_to_pk_bits() with which we
156 can ask for a bit-strength.  Without that, we stick to the constant we had
157 before, for now. */
158 #define EXIM_SERVER_DH_BITS_PRE2_12 1024
159
160 #define exim_gnutls_err_check(Label) do { \
161   if (rc != GNUTLS_E_SUCCESS) { return tls_error((Label), gnutls_strerror(rc), host); } } while (0)
162
163 #define expand_check_tlsvar(Varname) expand_check(state->Varname, US #Varname, &state->exp_##Varname)
164
165 #if GNUTLS_VERSION_NUMBER >= 0x020c00
166 #define HAVE_GNUTLS_SESSION_CHANNEL_BINDING
167 #define HAVE_GNUTLS_SEC_PARAM_CONSTANTS
168 #define HAVE_GNUTLS_RND
169 #endif
170
171
172
173
174 /* ------------------------------------------------------------------------ */
175 /* Callback declarations */
176
177 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
178 static void exim_gnutls_logger_cb(int level, const char *message);
179 #endif
180
181 static int exim_sni_handling_cb(gnutls_session_t session);
182
183
184
185
186 /* ------------------------------------------------------------------------ */
187 /* Static functions */
188
189 /*************************************************
190 *               Handle TLS error                 *
191 *************************************************/
192
193 /* Called from lots of places when errors occur before actually starting to do
194 the TLS handshake, that is, while the session is still in clear. Always returns
195 DEFER for a server and FAIL for a client so that most calls can use "return
196 tls_error(...)" to do this processing and then give an appropriate return. A
197 single function is used for both server and client, because it is called from
198 some shared functions.
199
200 Argument:
201   prefix    text to include in the logged error
202   msg       additional error string (may be NULL)
203             usually obtained from gnutls_strerror()
204   host      NULL if setting up a server;
205             the connected host if setting up a client
206
207 Returns:    OK/DEFER/FAIL
208 */
209
210 static int
211 tls_error(const uschar *prefix, const char *msg, const host_item *host)
212 {
213 if (host)
214   {
215   log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s)%s%s",
216       host->name, host->address, prefix, msg ? ": " : "", msg ? msg : "");
217   return FAIL;
218   }
219 else
220   {
221   uschar *conn_info = smtp_get_connection_info();
222   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0)
223     conn_info += 5;
224   log_write(0, LOG_MAIN, "TLS error on %s (%s)%s%s",
225       conn_info, prefix, msg ? ": " : "", msg ? msg : "");
226   return DEFER;
227   }
228 }
229
230
231
232
233 /*************************************************
234 *    Deal with logging errors during I/O         *
235 *************************************************/
236
237 /* We have to get the identity of the peer from saved data.
238
239 Argument:
240   state    the current GnuTLS exim state container
241   rc       the GnuTLS error code, or 0 if it's a local error
242   when     text identifying read or write
243   text     local error text when ec is 0
244
245 Returns:   nothing
246 */
247
248 static void
249 record_io_error(exim_gnutls_state_st *state, int rc, uschar *when, uschar *text)
250 {
251 const char *msg;
252
253 if (rc == GNUTLS_E_FATAL_ALERT_RECEIVED)
254   msg = CS string_sprintf("%s: %s", US gnutls_strerror(rc),
255     US gnutls_alert_get_name(gnutls_alert_get(state->session)));
256 else
257   msg = gnutls_strerror(rc);
258
259 tls_error(when, msg, state->host);
260 }
261
262
263
264
265 /*************************************************
266 *        Set various Exim expansion vars         *
267 *************************************************/
268
269 /* We set various Exim global variables from the state, once a session has
270 been established.  With TLS callouts, may need to change this to stack
271 variables, or just re-call it with the server state after client callout
272 has finished.
273
274 Make sure anything set here is inset in tls_getc().
275
276 Sets:
277   tls_active                fd
278   tls_bits                  strength indicator
279   tls_certificate_verified  bool indicator
280   tls_channelbinding_b64    for some SASL mechanisms
281   tls_cipher                a string
282   tls_peerdn                a string
283   tls_sni                   a (UTF-8) string
284 Also:
285   current_global_tls_state  for API limitations
286
287 Argument:
288   state      the relevant exim_gnutls_state_st *
289 */
290
291 static void
292 extract_exim_vars_from_tls_state(exim_gnutls_state_st *state)
293 {
294 gnutls_protocol_t protocol;
295 gnutls_cipher_algorithm_t cipher;
296 gnutls_kx_algorithm_t kx;
297 gnutls_mac_algorithm_t mac;
298 uschar *p;
299 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
300 int old_pool;
301 int rc;
302 gnutls_datum_t channel;
303 #endif
304
305 current_global_tls_state = state;
306
307 tls_active = state->fd_out;
308
309 cipher = gnutls_cipher_get(state->session);
310 /* returns size in "bytes" */
311 tls_bits = gnutls_cipher_get_key_size(cipher) * 8;
312
313 if (!*state->cipherbuf)
314   {
315   protocol = gnutls_protocol_get_version(state->session);
316   mac = gnutls_mac_get(state->session);
317   kx = gnutls_kx_get(state->session);
318
319   string_format(state->cipherbuf, sizeof(state->cipherbuf),
320       "%s:%s:%u",
321       gnutls_protocol_get_name(protocol),
322       gnutls_cipher_suite_get_name(kx, cipher, mac),
323       tls_bits);
324
325   /* I don't see a way that spaces could occur, in the current GnuTLS
326   code base, but it was a concern in the old code and perhaps older GnuTLS
327   releases did return "TLS 1.0"; play it safe, just in case. */
328   for (p = state->cipherbuf; *p != '\0'; ++p)
329     if (isspace(*p))
330       *p = '-';
331   }
332 tls_cipher = state->cipherbuf;
333
334 DEBUG(D_tls) debug_printf("cipher: %s\n", tls_cipher);
335
336 tls_certificate_verified = state->peer_cert_verified;
337
338 /* note that tls_channelbinding_b64 is not saved to the spool file, since it's
339 only available for use for authenticators while this TLS session is running. */
340
341 tls_channelbinding_b64 = NULL;
342 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
343 channel.data = NULL;
344 channel.size = 0;
345 rc = gnutls_session_channel_binding(state->session, GNUTLS_CB_TLS_UNIQUE, &channel);
346 if (rc) {
347   DEBUG(D_tls) debug_printf("Channel binding error: %s\n", gnutls_strerror(rc));
348 } else {
349   old_pool = store_pool;
350   store_pool = POOL_PERM;
351   tls_channelbinding_b64 = auth_b64encode(channel.data, (int)channel.size);
352   store_pool = old_pool;
353   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage.\n");
354 }
355 #endif
356
357 tls_peerdn = state->peerdn;
358
359 tls_sni = state->received_sni;
360 }
361
362
363
364
365 /*************************************************
366 *            Setup up DH parameters              *
367 *************************************************/
368
369 /* Generating the D-H parameters may take a long time. They only need to
370 be re-generated every so often, depending on security policy. What we do is to
371 keep these parameters in a file in the spool directory. If the file does not
372 exist, we generate them. This means that it is easy to cause a regeneration.
373
374 The new file is written as a temporary file and renamed, so that an incomplete
375 file is never present. If two processes both compute some new parameters, you
376 waste a bit of effort, but it doesn't seem worth messing around with locking to
377 prevent this.
378
379 Argument:
380   host       NULL for server, server for client (for error handling)
381
382 Returns:     OK/DEFER/FAIL
383 */
384
385 static int
386 init_server_dh(void)
387 {
388 int fd, rc;
389 unsigned int dh_bits;
390 gnutls_datum m;
391 uschar filename[PATH_MAX];
392 size_t sz;
393 host_item *host = NULL; /* dummy for macros */
394
395 DEBUG(D_tls) debug_printf("Initialising GnuTLS server params.\n");
396
397 rc = gnutls_dh_params_init(&dh_server_params);
398 exim_gnutls_err_check(US"gnutls_dh_params_init");
399
400 #ifdef HAVE_GNUTLS_SEC_PARAM_CONSTANTS
401 /* If you change this constant, also change dh_param_fn_ext so that we can use a
402 different filename and ensure we have sufficient bits. */
403 dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, GNUTLS_SEC_PARAM_NORMAL);
404 if (!dh_bits)
405   return tls_error(US"gnutls_sec_param_to_pk_bits() failed", NULL, NULL);
406 DEBUG(D_tls)
407   debug_printf("GnuTLS tells us that for D-H PK, NORMAL is %d bits.\n",
408       dh_bits);
409 #else
410 dh_bits = EXIM_SERVER_DH_BITS_PRE2_12;
411 DEBUG(D_tls)
412   debug_printf("GnuTLS lacks gnutls_sec_param_to_pk_bits(), using %d bits.\n",
413       dh_bits);
414 #endif
415
416 if (!string_format(filename, sizeof(filename),
417       "%s/gnutls-params-%d", spool_directory, dh_bits))
418   return tls_error(US"overlong filename", NULL, NULL);
419
420 /* Open the cache file for reading and if successful, read it and set up the
421 parameters. */
422
423 fd = Uopen(filename, O_RDONLY, 0);
424 if (fd >= 0)
425   {
426   struct stat statbuf;
427   FILE *fp;
428   int saved_errno;
429
430   if (fstat(fd, &statbuf) < 0)  /* EIO */
431     {
432     saved_errno = errno;
433     (void)close(fd);
434     return tls_error(US"TLS cache stat failed", strerror(saved_errno), NULL);
435     }
436   if (!S_ISREG(statbuf.st_mode))
437     {
438     (void)close(fd);
439     return tls_error(US"TLS cache not a file", NULL, NULL);
440     }
441   fp = fdopen(fd, "rb");
442   if (!fp)
443     {
444     saved_errno = errno;
445     (void)close(fd);
446     return tls_error(US"fdopen(TLS cache stat fd) failed",
447         strerror(saved_errno), NULL);
448     }
449
450   m.size = statbuf.st_size;
451   m.data = malloc(m.size);
452   if (m.data == NULL)
453     {
454     fclose(fp);
455     return tls_error(US"malloc failed", strerror(errno), NULL);
456     }
457   sz = fread(m.data, m.size, 1, fp);
458   if (!sz)
459     {
460     saved_errno = errno;
461     fclose(fp);
462     free(m.data);
463     return tls_error(US"fread failed", strerror(saved_errno), NULL);
464     }
465   fclose(fp);
466
467   rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM);
468   free(m.data);
469   exim_gnutls_err_check(US"gnutls_dh_params_import_pkcs3");
470   DEBUG(D_tls) debug_printf("read D-H parameters from file \"%s\"\n", filename);
471   }
472
473 /* If the file does not exist, fall through to compute new data and cache it.
474 If there was any other opening error, it is serious. */
475
476 else if (errno == ENOENT)
477   {
478   rc = -1;
479   DEBUG(D_tls)
480     debug_printf("D-H parameter cache file \"%s\" does not exist\n", filename);
481   }
482 else
483   return tls_error(string_open_failed(errno, "\"%s\" for reading", filename),
484       NULL, NULL);
485
486 /* If ret < 0, either the cache file does not exist, or the data it contains
487 is not useful. One particular case of this is when upgrading from an older
488 release of Exim in which the data was stored in a different format. We don't
489 try to be clever and support both formats; we just regenerate new data in this
490 case. */
491
492 if (rc < 0)
493   {
494   uschar *temp_fn;
495
496   if ((PATH_MAX - Ustrlen(filename)) < 10)
497     return tls_error(US"Filename too long to generate replacement",
498         CS filename, NULL);
499
500   temp_fn = string_copy(US "%s.XXXXXXX");
501   fd = mkstemp(CS temp_fn); /* modifies temp_fn */
502   if (fd < 0)
503     return tls_error(US"Unable to open temp file", strerror(errno), NULL);
504   (void)fchown(fd, exim_uid, exim_gid);   /* Probably not necessary */
505
506   DEBUG(D_tls) debug_printf("generating %d bits Diffie-Hellman key ...\n", dh_bits);
507   rc = gnutls_dh_params_generate2(dh_server_params, dh_bits);
508   exim_gnutls_err_check(US"gnutls_dh_params_generate2");
509
510   /* gnutls_dh_params_export_pkcs3() will tell us the exact size, every time,
511   and I confirmed that a NULL call to get the size first is how the GnuTLS
512   sample apps handle this. */
513
514   sz = 0;
515   m.data = NULL;
516   rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
517       m.data, &sz);
518   if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
519     exim_gnutls_err_check(US"gnutls_dh_params_export_pkcs3(NULL) sizing");
520   m.size = sz;
521   m.data = malloc(m.size);
522   if (m.data == NULL)
523     return tls_error(US"memory allocation failed", strerror(errno), NULL);
524   rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
525       m.data, &sz);
526   if (rc != GNUTLS_E_SUCCESS)
527     {
528     free(m.data);
529     exim_gnutls_err_check(US"gnutls_dh_params_export_pkcs3() real");
530     }
531
532   sz = write_to_fd_buf(fd, m.data, (size_t) m.size);
533   if (sz != m.size)
534     {
535     free(m.data);
536     return tls_error(US"TLS cache write D-H params failed",
537         strerror(errno), NULL);
538     }
539   free(m.data);
540   sz = write_to_fd_buf(fd, US"\n", 1);
541   if (sz != 1)
542     return tls_error(US"TLS cache write D-H params final newline failed",
543         strerror(errno), NULL);
544
545   rc = close(fd);
546   if (rc)
547     return tls_error(US"TLS cache write close() failed",
548         strerror(errno), NULL);
549
550   if (Urename(temp_fn, filename) < 0)
551     return tls_error(string_sprintf("failed to rename \"%s\" as \"%s\"",
552           temp_fn, filename), strerror(errno), NULL);
553
554   DEBUG(D_tls) debug_printf("wrote D-H parameters to file \"%s\"\n", filename);
555   }
556
557 DEBUG(D_tls) debug_printf("initialized server D-H parameters\n");
558 return OK;
559 }
560
561
562
563
564 /*************************************************
565 *       Variables re-expanded post-SNI           *
566 *************************************************/
567
568 /* Called from both server and client code, via tls_init(), and also from
569 the SNI callback after receiving an SNI, if tls_certificate includes "tls_sni".
570
571 We can tell the two apart by state->received_sni being non-NULL in callback.
572
573 The callback should not call us unless state->trigger_sni_changes is true,
574 which we are responsible for setting on the first pass through.
575
576 Arguments:
577   state           exim_gnutls_state_st *
578
579 Returns:          OK/DEFER/FAIL
580 */
581
582 static int
583 tls_expand_session_files(exim_gnutls_state_st *state)
584 {
585 int rc;
586 const host_item *host = state->host;  /* macro should be reconsidered? */
587 uschar *saved_tls_certificate = NULL;
588 uschar *saved_tls_privatekey = NULL;
589 uschar *saved_tls_verify_certificates = NULL;
590 uschar *saved_tls_crl = NULL;
591 int cert_count;
592
593 /* We check for tls_sni *before* expansion. */
594 if (!state->host)
595   {
596   if (!state->received_sni)
597     {
598     if (Ustrstr(state->tls_certificate, US"tls_sni"))
599       {
600       DEBUG(D_tls) debug_printf("We will re-expand TLS session files if we receive SNI.\n");
601       state->trigger_sni_changes = TRUE;
602       }
603     }
604   else
605     {
606     saved_tls_certificate = state->exp_tls_certificate;
607     saved_tls_privatekey = state->exp_tls_privatekey;
608     saved_tls_verify_certificates = state->exp_tls_verify_certificates;
609     saved_tls_crl = state->exp_tls_crl;
610     }
611   }
612
613 /* remember: expand_check_tlsvar() is expand_check() but fiddling with
614 state members, assuming consistent naming; and expand_check() returns
615 false if expansion failed, unless expansion was forced to fail. */
616
617 /* check if we at least have a certificate, before doing expensive
618 D-H generation. */
619
620 if (!expand_check_tlsvar(tls_certificate))
621   return DEFER;
622
623 /* certificate is mandatory in server, optional in client */
624
625 if ((state->exp_tls_certificate == NULL) ||
626     (*state->exp_tls_certificate == '\0'))
627   {
628   if (state->host == NULL)
629     return tls_error(US"no TLS server certificate is specified", NULL, NULL);
630   else
631     DEBUG(D_tls) debug_printf("TLS: no client certificate specified; okay\n");
632   }
633
634 if (state->tls_privatekey && !expand_check_tlsvar(tls_privatekey))
635   return DEFER;
636
637 /* tls_privatekey is optional, defaulting to same file as certificate */
638
639 if (state->tls_privatekey == NULL || *state->tls_privatekey == '\0')
640   {
641   state->tls_privatekey = state->tls_certificate;
642   state->exp_tls_privatekey = state->exp_tls_certificate;
643   }
644
645
646 if (state->exp_tls_certificate && *state->exp_tls_certificate)
647   {
648   BOOL setit = TRUE;
649   DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
650       state->exp_tls_certificate, state->exp_tls_privatekey);
651
652   if (state->received_sni)
653     {
654     if ((Ustrcmp(state->exp_tls_certificate, saved_tls_certificate) == 0) &&
655         (Ustrcmp(state->exp_tls_privatekey, saved_tls_privatekey) == 0))
656       {
657       DEBUG(D_tls) debug_printf("TLS SNI: cert and key unchanged\n");
658       setit = FALSE;
659       }
660     else
661       {
662       DEBUG(D_tls) debug_printf("TLS SNI: have a changed cert/key pair.\n");
663       }
664     }
665
666   if (setit)
667     {
668     rc = gnutls_certificate_set_x509_key_file(state->x509_cred,
669         CS state->exp_tls_certificate, CS state->exp_tls_privatekey,
670         GNUTLS_X509_FMT_PEM);
671     exim_gnutls_err_check(
672         string_sprintf("cert/key setup: cert=%s key=%s",
673           state->exp_tls_certificate, state->exp_tls_privatekey));
674     DEBUG(D_tls) debug_printf("TLS: cert/key registered\n");
675     }
676   } /* tls_certificate */
677
678 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
679 provided. Experiment shows that, if the certificate file is empty, an unhelpful
680 error message is provided. However, if we just refrain from setting anything up
681 in that case, certificate verification fails, which seems to be the correct
682 behaviour. */
683
684 if (state->tls_verify_certificates && *state->tls_verify_certificates)
685   {
686   struct stat statbuf;
687   BOOL setit_vc = TRUE, setit_crl = TRUE;
688
689   if (!expand_check_tlsvar(tls_verify_certificates))
690     return DEFER;
691   if (state->tls_crl && *state->tls_crl)
692     if (!expand_check_tlsvar(tls_crl))
693       return DEFER;
694
695   if (state->received_sni)
696     {
697     state->exp_tls_verify_certificates, state->exp_tls_verify_certificates,
698     saved_tls_verify_certificates, saved_tls_verify_certificates);
699     if (!(state->exp_tls_verify_certificates || saved_tls_verify_certificates))
700       setit_vc = FALSE; /* never was set */
701     else if (!state->exp_tls_verify_certificates || !saved_tls_verify_certificates)
702       setit_vc = TRUE; /* changed whether set */
703     else if (Ustrcmp(state->exp_tls_verify_certificates, saved_tls_verify_certificates) == 0)
704       setit_vc = FALSE; /* not changed value */
705
706     state->exp_tls_crl, state->exp_tls_crl,
707     saved_tls_crl, saved_tls_crl);
708     if (!(state->exp_tls_crl || saved_tls_crl))
709       setit_crl = FALSE; /* never was set */
710     else if (!state->exp_tls_crl || !saved_tls_crl)
711       setit_crl = TRUE; /* changed whether set */
712     else if (Ustrcmp(state->exp_tls_crl, saved_tls_crl) == 0)
713       setit_crl = FALSE; /* not changed value */
714     }
715
716   /* nb: early exit; change if add more expansions to this function */
717   if (!(setit_vc || setit_crl))
718     {
719     DEBUG(D_tls)
720       debug_printf("TLS SNI: no change to tls_crl or tls_verify_certificates\n");
721     return OK;
722     }
723
724   if (Ustat(state->exp_tls_verify_certificates, &statbuf) < 0)
725     {
726     log_write(0, LOG_MAIN|LOG_PANIC, "could not stat %s "
727         "(tls_verify_certificates): %s", state->exp_tls_verify_certificates,
728         strerror(errno));
729     return DEFER;
730     }
731
732   if (!S_ISREG(statbuf.st_mode))
733     {
734     DEBUG(D_tls)
735       debug_printf("verify certificates path is not a file: \"%s\"\n%s\n",
736           state->exp_tls_verify_certificates,
737           S_ISDIR(statbuf.st_mode)
738             ? " it's a directory, that's OpenSSL, this is GnuTLS"
739             : " (not a directory either)");
740     log_write(0, LOG_MAIN|LOG_PANIC,
741         "tls_verify_certificates \"%s\" is not a file",
742         state->exp_tls_verify_certificates);
743     return DEFER;
744     }
745
746   DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
747           state->exp_tls_verify_certificates, statbuf.st_size);
748
749   /* If the CA cert file is empty, there's no point in loading the CRL file,
750   as we aren't verifying, so checking for revocation is pointless. */
751
752   if (statbuf.st_size > 0)
753     {
754     if (setit_vc)
755       {
756       cert_count = gnutls_certificate_set_x509_trust_file(state->x509_cred,
757           CS state->exp_tls_verify_certificates, GNUTLS_X509_FMT_PEM);
758       if (cert_count < 0)
759         {
760         rc = cert_count;
761         exim_gnutls_err_check(US"gnutls_certificate_set_x509_trust_file");
762         }
763       DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n", cert_count);
764       }
765     else
766       {
767       DEBUG(D_tls) debug_printf("TLS SNI: tls_verify_certificates unchanged\n");
768       }
769
770     if (setit_crl && state->tls_crl && *state->tls_crl)
771       {
772       if (state->exp_tls_crl && *state->exp_tls_crl)
773         {
774         DEBUG(D_tls) debug_printf("loading CRL file = %s\n", state->exp_tls_crl);
775         rc = gnutls_certificate_set_x509_crl_file(state->x509_cred,
776             CS state->exp_tls_crl, GNUTLS_X509_FMT_PEM);
777         exim_gnutls_err_check(US"gnutls_certificate_set_x509_crl_file");
778         }
779       }
780     DEBUG(D_tls)
781       if (!setit_crl) debug_printf("TLS SNI: tls_crl unchanged\n");
782     } /* statbuf.st_size */
783   } /* tls_verify_certificates */
784
785 return OK;
786 /* also above, during verify_certificates/crl, during SNI, if unchanged */
787 }
788
789
790
791
792 /*************************************************
793 *            Initialize for GnuTLS               *
794 *************************************************/
795
796 /* Called from both server and client code. In the case of a server, errors
797 before actual TLS negotiation return DEFER.
798
799 Arguments:
800   host            connected host, if client; NULL if server
801   certificate     certificate file
802   privatekey      private key file
803   sni             TLS SNI to send, sometimes when client; else NULL
804   cas             CA certs file
805   crl             CRL file
806   require_ciphers tls_require_ciphers setting
807
808 Returns:          OK/DEFER/FAIL
809 */
810
811 static int
812 tls_init(
813     const host_item *host,
814     const uschar *certificate,
815     const uschar *privatekey,
816     const uschar *sni,
817     const uschar *cas,
818     const uschar *crl,
819     const uschar *require_ciphers,
820     exim_gnutls_state_st **caller_state)
821 {
822 exim_gnutls_state_st *state;
823 int rc;
824 size_t sz;
825 const char *errpos;
826 uschar *p;
827 BOOL want_default_priorities;
828
829 if (!exim_gnutls_base_init_done)
830   {
831   DEBUG(D_tls) debug_printf("GnuTLS global init required.\n");
832
833   rc = gnutls_global_init();
834   exim_gnutls_err_check(US"gnutls_global_init");
835
836 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
837   DEBUG(D_tls)
838     {
839     gnutls_global_set_log_function(exim_gnutls_logger_cb);
840     /* arbitrarily chosen level; bump upto 9 for more */
841     gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL);
842     }
843 #endif
844
845   exim_gnutls_base_init_done = TRUE;
846   }
847
848 if (host)
849   {
850   state = &state_client;
851   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
852   DEBUG(D_tls) debug_printf("initialising GnuTLS client session\n");
853   rc = gnutls_init(&state->session, GNUTLS_CLIENT);
854   }
855 else
856   {
857   state = &state_server;
858   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
859   DEBUG(D_tls) debug_printf("initialising GnuTLS server session\n");
860   rc = gnutls_init(&state->session, GNUTLS_SERVER);
861   }
862 exim_gnutls_err_check(US"gnutls_init");
863
864 state->host = host;
865
866 state->tls_certificate = certificate;
867 state->tls_privatekey = privatekey;
868 state->tls_sni = sni;
869 state->tls_verify_certificates = cas;
870 state->tls_crl = crl;
871
872 rc = gnutls_certificate_allocate_credentials(&state->x509_cred);
873 exim_gnutls_err_check(US"gnutls_certificate_allocate_credentials");
874
875 /* This handles the variables that might get re-expanded after TLS SNI;
876 that's tls_certificate, tls_privatekey, tls_verify_certificates, tls_crl */
877
878 DEBUG(D_tls)
879   debug_printf("Expanding various TLS configuration options for session credentials.\n");
880 rc = tls_expand_session_files(state);
881 if (rc != OK) return rc;
882
883 /* Create D-H parameters, or read them from the cache file. This function does
884 its own SMTP error messaging. This only happens for the server, TLS D-H ignores
885 client-side params. */
886
887 if (!host)
888   {
889   rc = init_server_dh();
890   if (rc != OK) return rc;
891   gnutls_certificate_set_dh_params(state->x509_cred, dh_server_params);
892   }
893
894 /* Link the credentials to the session. */
895
896 rc = gnutls_credentials_set(state->session, GNUTLS_CRD_CERTIFICATE, state->x509_cred);
897 exim_gnutls_err_check(US"gnutls_credentials_set");
898
899 /* set SNI in client, only */
900 if (host)
901   {
902   if (!expand_check_tlsvar(tls_sni))
903     return DEFER;
904   if (state->exp_tls_sni && *state->exp_tls_sni)
905     {
906     DEBUG(D_tls)
907       debug_printf("Setting TLS client SNI to \"%s\"\n", state->exp_tls_sni);
908     sz = Ustrlen(state->exp_tls_sni);
909     rc = gnutls_server_name_set(state->session,
910         GNUTLS_NAME_DNS, state->exp_tls_sni, sz);
911     exim_gnutls_err_check(US"gnutls_server_name_set");
912     }
913   }
914 else if (state->tls_sni)
915   DEBUG(D_tls) debug_printf("*** PROBABLY A BUG *** " \
916       "have an SNI set for a client [%s]\n", state->tls_sni);
917
918 /* This is the priority string support,
919 http://www.gnu.org/software/gnutls/manual/html_node/Priority-Strings.html
920 and replaces gnutls_require_kx, gnutls_require_mac & gnutls_require_protocols.
921 This was backwards incompatible, but means Exim no longer needs to track
922 all algorithms and provide string forms for them. */
923
924 want_default_priorities = TRUE;
925
926 if (state->tls_require_ciphers && *state->tls_require_ciphers)
927   {
928   if (!expand_check_tlsvar(tls_require_ciphers))
929     return DEFER;
930   if (state->exp_tls_require_ciphers && *state->exp_tls_require_ciphers)
931     {
932     DEBUG(D_tls) debug_printf("GnuTLS session cipher/priority \"%s\"\n",
933         state->exp_tls_require_ciphers);
934
935     rc = gnutls_priority_init(&state->priority_cache,
936         CS state->exp_tls_require_ciphers, &errpos);
937     want_default_priorities = FALSE;
938     p = state->exp_tls_require_ciphers;
939     }
940   }
941 if (want_default_priorities)
942   {
943   rc = gnutls_priority_init(&state->priority_cache,
944       exim_default_gnutls_priority, &errpos);
945   p = US exim_default_gnutls_priority;
946   }
947
948 exim_gnutls_err_check(string_sprintf(
949       "gnutls_priority_init(%s) failed at offset %ld, \"%.6s..\"",
950       p, errpos - CS p, errpos));
951
952 rc = gnutls_priority_set(state->session, state->priority_cache);
953 exim_gnutls_err_check(US"gnutls_priority_set");
954
955 gnutls_db_set_cache_expiration(state->session, ssl_session_timeout);
956
957 /* Reduce security in favour of increased compatibility, if the admin
958 decides to make that trade-off. */
959 if (gnutls_compat_mode)
960   {
961 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
962   DEBUG(D_tls) debug_printf("lowering GnuTLS security, compatibility mode\n");
963   gnutls_session_enable_compatibility_mode(state->session);
964 #else
965   DEBUG(D_tls) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
966 #endif
967   }
968
969 *caller_state = state;
970 /* needs to happen before callbacks during handshake */
971 current_global_tls_state = state;
972 return OK;
973 }
974
975
976
977
978 /*************************************************
979 *            Extract peer information            *
980 *************************************************/
981
982 /* Called from both server and client code.
983 Only this is allowed to set state->peerdn and we use that to detect double-calls.
984
985 Arguments:
986   state           exim_gnutls_state_st *
987
988 Returns:          OK/DEFER/FAIL
989 */
990
991 static int
992 peer_status(exim_gnutls_state_st *state)
993 {
994 const gnutls_datum *cert_list;
995 int rc;
996 unsigned int cert_list_size = 0;
997 gnutls_certificate_type_t ct;
998 gnutls_x509_crt_t crt;
999 uschar *dn_buf;
1000 size_t sz;
1001
1002 if (state->peerdn)
1003   return OK;
1004
1005 state->peerdn = US"unknown";
1006
1007 cert_list = gnutls_certificate_get_peers(state->session, &cert_list_size);
1008
1009 if (cert_list == NULL || cert_list_size == 0)
1010   {
1011   state->peerdn = US"unknown (no certificate)";
1012   DEBUG(D_tls) debug_printf("TLS: no certificate from peer (%p & %d)\n",
1013       cert_list, cert_list_size);
1014   if (state->verify_requirement == VERIFY_REQUIRED)
1015     return tls_error(US"certificate verification failed",
1016         "no certificate received from peer", state->host);
1017   return OK;
1018   }
1019
1020 ct = gnutls_certificate_type_get(state->session);
1021 if (ct != GNUTLS_CRT_X509)
1022   {
1023   const char *ctn = gnutls_certificate_type_get_name(ct);
1024   state->peerdn = string_sprintf("unknown (type %s)", ctn);
1025   DEBUG(D_tls)
1026     debug_printf("TLS: peer cert not X.509 but instead \"%s\"\n", ctn);
1027   if (state->verify_requirement == VERIFY_REQUIRED)
1028     return tls_error(US"certificate verification not possible, unhandled type",
1029         ctn, state->host);
1030   return OK;
1031   }
1032
1033 #define exim_gnutls_peer_err(Label) do { \
1034   if (rc != GNUTLS_E_SUCCESS) { \
1035     DEBUG(D_tls) debug_printf("TLS: peer cert problem: %s: %s\n", (Label), gnutls_strerror(rc)); \
1036     if (state->verify_requirement == VERIFY_REQUIRED) { return tls_error((Label), gnutls_strerror(rc), state->host); } \
1037     return OK; } } while (0)
1038
1039 rc = gnutls_x509_crt_init(&crt);
1040 exim_gnutls_peer_err(US"gnutls_x509_crt_init (crt)");
1041
1042 rc = gnutls_x509_crt_import(crt, &cert_list[0], GNUTLS_X509_FMT_DER);
1043 exim_gnutls_peer_err(US"failed to import certificate [gnutls_x509_crt_import(cert 0)]");
1044 sz = 0;
1045 rc = gnutls_x509_crt_get_dn(crt, NULL, &sz);
1046 if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
1047   {
1048   exim_gnutls_peer_err(US"getting size for cert DN failed");
1049   return FAIL; /* should not happen */
1050   }
1051 dn_buf = store_get_perm(sz);
1052 rc = gnutls_x509_crt_get_dn(crt, CS dn_buf, &sz);
1053 exim_gnutls_peer_err(US"failed to extract certificate DN [gnutls_x509_crt_get_dn(cert 0)]");
1054 state->peerdn = dn_buf;
1055
1056 return OK;
1057 #undef exim_gnutls_peer_err
1058 }
1059
1060
1061
1062
1063 /*************************************************
1064 *            Verify peer certificate             *
1065 *************************************************/
1066
1067 /* Called from both server and client code.
1068 *Should* be using a callback registered with
1069 gnutls_certificate_set_verify_function() to fail the handshake if we dislike
1070 the peer information, but that's too new for some OSes.
1071
1072 Arguments:
1073   state           exim_gnutls_state_st *
1074   error           where to put an error message
1075
1076 Returns:
1077   FALSE     if the session should be rejected
1078   TRUE      if the cert is okay or we just don't care
1079 */
1080
1081 static BOOL
1082 verify_certificate(exim_gnutls_state_st *state, const char **error)
1083 {
1084 int rc;
1085 unsigned int verify;
1086
1087 *error = NULL;
1088
1089 rc = peer_status(state);
1090 if (rc != OK)
1091   {
1092   verify = GNUTLS_CERT_INVALID;
1093   *error = "not supplied";
1094   }
1095 else
1096   {
1097   rc = gnutls_certificate_verify_peers2(state->session, &verify);
1098   }
1099
1100 /* Handle the result of verification. INVALID seems to be set as well
1101 as REVOKED, but leave the test for both. */
1102
1103 if ((rc < 0) || (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED)) != 0)
1104   {
1105   state->peer_cert_verified = FALSE;
1106   if (*error == NULL)
1107     *error = ((verify & GNUTLS_CERT_REVOKED) != 0) ? "revoked" : "invalid";
1108
1109   DEBUG(D_tls)
1110     debug_printf("TLS certificate verification failed (%s): peerdn=%s\n",
1111         *error, state->peerdn);
1112
1113   if (state->verify_requirement == VERIFY_REQUIRED)
1114     {
1115     gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
1116     return FALSE;
1117     }
1118   DEBUG(D_tls)
1119     debug_printf("TLS verify failure overriden (host in tls_try_verify_hosts)\n");
1120   }
1121 else
1122   {
1123   state->peer_cert_verified = TRUE;
1124   DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=%s\n", state->peerdn);
1125   }
1126
1127 tls_peerdn = state->peerdn;
1128
1129 return TRUE;
1130 }
1131
1132
1133
1134
1135 /* ------------------------------------------------------------------------ */
1136 /* Callbacks */
1137
1138 /* Logging function which can be registered with
1139  *   gnutls_global_set_log_function()
1140  *   gnutls_global_set_log_level() 0..9
1141  */
1142 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
1143 static void
1144 exim_gnutls_logger_cb(int level, const char *message)
1145 {
1146   DEBUG(D_tls) debug_printf("GnuTLS<%d>: %s\n", level, message);
1147 }
1148 #endif
1149
1150
1151 /* Called after client hello, should handle SNI work.
1152 This will always set tls_sni (state->received_sni) if available,
1153 and may trigger presenting different certificates,
1154 if state->trigger_sni_changes is TRUE.
1155
1156 Should be registered with
1157   gnutls_handshake_set_post_client_hello_function()
1158
1159 "This callback must return 0 on success or a gnutls error code to terminate the
1160 handshake.".
1161
1162 For inability to get SNI information, we return 0.
1163 We only return non-zero if re-setup failed.
1164 */
1165
1166 static int
1167 exim_sni_handling_cb(gnutls_session_t session)
1168 {
1169 char sni_name[MAX_HOST_LEN];
1170 size_t data_len = MAX_HOST_LEN;
1171 exim_gnutls_state_st *state = current_global_tls_state;
1172 unsigned int sni_type;
1173 int rc, old_pool;
1174
1175 rc = gnutls_server_name_get(session, sni_name, &data_len, &sni_type, 0);
1176 if (rc != GNUTLS_E_SUCCESS)
1177   {
1178   DEBUG(D_tls) {
1179     if (rc == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
1180       debug_printf("TLS: no SNI presented in handshake.\n");
1181     else
1182       debug_printf("TLS failure: gnutls_server_name_get(): %s [%d]\n",
1183         gnutls_strerror(rc), rc);
1184   };
1185   return 0;
1186   }
1187
1188 if (sni_type != GNUTLS_NAME_DNS)
1189   {
1190   DEBUG(D_tls) debug_printf("TLS: ignoring SNI of unhandled type %u\n", sni_type);
1191   return 0;
1192   }
1193
1194 /* We now have a UTF-8 string in sni_name */
1195 old_pool = store_pool;
1196 store_pool = POOL_PERM;
1197 state->received_sni = string_copyn(US sni_name, data_len);
1198 store_pool = old_pool;
1199
1200 /* We set this one now so that variable expansions below will work */
1201 tls_sni = state->received_sni;
1202
1203 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", sni_name,
1204     state->trigger_sni_changes ? "" : " (unused for certificate selection)");
1205
1206 if (!state->trigger_sni_changes)
1207   return 0;
1208
1209 rc = tls_expand_session_files(state);
1210 if (rc != OK)
1211   {
1212   /* If the setup of certs/etc failed before handshake, TLS would not have
1213   been offered.  The best we can do now is abort. */
1214   return GNUTLS_E_APPLICATION_ERROR_MIN;
1215   }
1216
1217 rc = gnutls_credentials_set(state->session, GNUTLS_CRD_CERTIFICATE, state->x509_cred);
1218 return (rc == GNUTLS_E_SUCCESS) ? 0 : rc;
1219 }
1220
1221
1222
1223
1224 /* ------------------------------------------------------------------------ */
1225 /* Exported functions */
1226
1227
1228
1229
1230 /*************************************************
1231 *       Start a TLS session in a server          *
1232 *************************************************/
1233
1234 /* This is called when Exim is running as a server, after having received
1235 the STARTTLS command. It must respond to that command, and then negotiate
1236 a TLS session.
1237
1238 Arguments:
1239   require_ciphers  list of allowed ciphers or NULL
1240
1241 Returns:           OK on success
1242                    DEFER for errors before the start of the negotiation
1243                    FAIL for errors during the negotation; the server can't
1244                      continue running.
1245 */
1246
1247 int
1248 tls_server_start(const uschar *require_ciphers)
1249 {
1250 int rc;
1251 const char *error;
1252 exim_gnutls_state_st *state = NULL;
1253
1254 /* Check for previous activation */
1255 /* nb: this will not be TLS callout safe, needs reworking as part of that. */
1256
1257 if (tls_active >= 0)
1258   {
1259   tls_error(US"STARTTLS received after TLS started", "", NULL);
1260   smtp_printf("554 Already in TLS\r\n");
1261   return FAIL;
1262   }
1263
1264 /* Initialize the library. If it fails, it will already have logged the error
1265 and sent an SMTP response. */
1266
1267 DEBUG(D_tls) debug_printf("initialising GnuTLS as a server\n");
1268
1269 rc = tls_init(NULL, tls_certificate, tls_privatekey,
1270     NULL, tls_verify_certificates, tls_crl,
1271     require_ciphers, &state);
1272 if (rc != OK) return rc;
1273
1274 /* If this is a host for which certificate verification is mandatory or
1275 optional, set up appropriately. */
1276
1277 if (verify_check_host(&tls_verify_hosts) == OK)
1278   {
1279   DEBUG(D_tls) debug_printf("TLS: a client certificate will be required.\n");
1280   state->verify_requirement = VERIFY_REQUIRED;
1281   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
1282   }
1283 else if (verify_check_host(&tls_try_verify_hosts) == OK)
1284   {
1285   DEBUG(D_tls) debug_printf("TLS: a client certificate will be requested but not required.\n");
1286   state->verify_requirement = VERIFY_OPTIONAL;
1287   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
1288   }
1289 else
1290   {
1291   DEBUG(D_tls) debug_printf("TLS: a client certificate will not be requested.\n");
1292   state->verify_requirement = VERIFY_NONE;
1293   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
1294   }
1295
1296 /* Register SNI handling; always, even if not in tls_certificate, so that the
1297 expansion variable $tls_sni is always available. */
1298
1299 gnutls_handshake_set_post_client_hello_function(state->session,
1300     exim_sni_handling_cb);
1301
1302 /* Set context and tell client to go ahead, except in the case of TLS startup
1303 on connection, where outputting anything now upsets the clients and tends to
1304 make them disconnect. We need to have an explicit fflush() here, to force out
1305 the response. Other smtp_printf() calls do not need it, because in non-TLS
1306 mode, the fflush() happens when smtp_getc() is called. */
1307
1308 if (!tls_on_connect)
1309   {
1310   smtp_printf("220 TLS go ahead\r\n");
1311   fflush(smtp_out);
1312   }
1313
1314 /* Now negotiate the TLS session. We put our own timer on it, since it seems
1315 that the GnuTLS library doesn't. */
1316
1317 gnutls_transport_set_ptr2(state->session,
1318     (gnutls_transport_ptr)fileno(smtp_in),
1319     (gnutls_transport_ptr)fileno(smtp_out));
1320 state->fd_in = fileno(smtp_in);
1321 state->fd_out = fileno(smtp_out);
1322
1323 sigalrm_seen = FALSE;
1324 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1325 do
1326   {
1327   rc = gnutls_handshake(state->session);
1328   } while ((rc == GNUTLS_E_AGAIN) || (rc == GNUTLS_E_INTERRUPTED));
1329 alarm(0);
1330
1331 if (rc != GNUTLS_E_SUCCESS)
1332   {
1333   tls_error(US"gnutls_handshake",
1334       sigalrm_seen ? "timed out" : gnutls_strerror(rc), NULL);
1335   /* It seems that, except in the case of a timeout, we have to close the
1336   connection right here; otherwise if the other end is running OpenSSL it hangs
1337   until the server times out. */
1338
1339   if (!sigalrm_seen)
1340     {
1341     (void)fclose(smtp_out);
1342     (void)fclose(smtp_in);
1343     }
1344
1345   return FAIL;
1346   }
1347
1348 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
1349
1350 /* Verify after the fact */
1351
1352 if (state->verify_requirement != VERIFY_NONE)
1353   {
1354   if (!verify_certificate(state, &error))
1355     {
1356     if (state->verify_requirement == VERIFY_OPTIONAL)
1357       {
1358       DEBUG(D_tls)
1359         debug_printf("TLS: continuing on only because verification was optional, after: %s\n",
1360             error);
1361       }
1362     else
1363       {
1364       tls_error(US"certificate verification failed", error, NULL);
1365       return FAIL;
1366       }
1367     }
1368   }
1369
1370 /* Figure out peer DN, and if authenticated, etc. */
1371
1372 rc = peer_status(state);
1373 if (rc != OK) return rc;
1374
1375 /* Sets various Exim expansion variables; always safe within server */
1376
1377 extract_exim_vars_from_tls_state(state);
1378
1379 /* TLS has been set up. Adjust the input functions to read via TLS,
1380 and initialize appropriately. */
1381
1382 state->xfer_buffer = store_malloc(ssl_xfer_buffer_size);
1383
1384 receive_getc = tls_getc;
1385 receive_ungetc = tls_ungetc;
1386 receive_feof = tls_feof;
1387 receive_ferror = tls_ferror;
1388 receive_smtp_buffered = tls_smtp_buffered;
1389
1390 return OK;
1391 }
1392
1393
1394
1395
1396 /*************************************************
1397 *    Start a TLS session in a client             *
1398 *************************************************/
1399
1400 /* Called from the smtp transport after STARTTLS has been accepted.
1401
1402 Arguments:
1403   fd                the fd of the connection
1404   host              connected host (for messages)
1405   addr              the first address (not used)
1406   dhparam           DH parameter file (ignored, we're a client)
1407   certificate       certificate file
1408   privatekey        private key file
1409   sni               TLS SNI to send to remote host
1410   verify_certs      file for certificate verify
1411   verify_crl        CRL for verify
1412   require_ciphers   list of allowed ciphers or NULL
1413   timeout           startup timeout
1414
1415 Returns:            OK/DEFER/FAIL (because using common functions),
1416                     but for a client, DEFER and FAIL have the same meaning
1417 */
1418
1419 int
1420 tls_client_start(int fd, host_item *host,
1421     address_item *addr ARG_UNUSED, uschar *dhparam ARG_UNUSED,
1422     uschar *certificate, uschar *privatekey, uschar *sni,
1423     uschar *verify_certs, uschar *verify_crl,
1424     uschar *require_ciphers, int timeout)
1425 {
1426 int rc;
1427 const char *error;
1428 exim_gnutls_state_st *state = NULL;
1429
1430 DEBUG(D_tls) debug_printf("initialising GnuTLS as a client on fd %d\n", fd);
1431
1432 rc = tls_init(host, certificate, privatekey,
1433     sni, verify_certs, verify_crl, require_ciphers, &state);
1434 if (rc != OK) return rc;
1435
1436 gnutls_dh_set_prime_bits(state->session, EXIM_CLIENT_DH_MIN_BITS);
1437
1438 if (verify_certs == NULL)
1439   {
1440   DEBUG(D_tls) debug_printf("TLS: server certificate verification not required\n");
1441   state->verify_requirement = VERIFY_NONE;
1442   /* we still ask for it, to log it, etc */
1443   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
1444   }
1445 else
1446   {
1447   DEBUG(D_tls) debug_printf("TLS: server certificate verification required\n");
1448   state->verify_requirement = VERIFY_REQUIRED;
1449   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
1450   }
1451
1452 gnutls_transport_set_ptr(state->session, (gnutls_transport_ptr)fd);
1453 state->fd_in = fd;
1454 state->fd_out = fd;
1455
1456 /* There doesn't seem to be a built-in timeout on connection. */
1457
1458 sigalrm_seen = FALSE;
1459 alarm(timeout);
1460 do
1461   {
1462   rc = gnutls_handshake(state->session);
1463   } while ((rc == GNUTLS_E_AGAIN) || (rc == GNUTLS_E_INTERRUPTED));
1464 alarm(0);
1465
1466 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
1467
1468 /* Verify late */
1469
1470 if (state->verify_requirement != VERIFY_NONE &&
1471     !verify_certificate(state, &error))
1472   return tls_error(US"certificate verification failed", error, state->host);
1473
1474 /* Figure out peer DN, and if authenticated, etc. */
1475
1476 rc = peer_status(state);
1477 if (rc != OK) return rc;
1478
1479 /* Sets various Exim expansion variables; always safe within server */
1480
1481 extract_exim_vars_from_tls_state(state);
1482
1483 return OK;
1484 }
1485
1486
1487
1488
1489 /*************************************************
1490 *         Close down a TLS session               *
1491 *************************************************/
1492
1493 /* This is also called from within a delivery subprocess forked from the
1494 daemon, to shut down the TLS library, without actually doing a shutdown (which
1495 would tamper with the TLS session in the parent process).
1496
1497 Arguments:   TRUE if gnutls_bye is to be called
1498 Returns:     nothing
1499 */
1500
1501 void
1502 tls_close(BOOL shutdown)
1503 {
1504 exim_gnutls_state_st *state = current_global_tls_state;
1505
1506 if (tls_active < 0) return;  /* TLS was not active */
1507
1508 if (shutdown)
1509   {
1510   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS\n");
1511   gnutls_bye(state->session, GNUTLS_SHUT_WR);
1512   }
1513
1514 gnutls_deinit(state->session);
1515
1516 memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
1517
1518 if ((state_server.session == NULL) && (state_client.session == NULL))
1519   {
1520   gnutls_global_deinit();
1521   exim_gnutls_base_init_done = FALSE;
1522   }
1523
1524 tls_active = -1;
1525 }
1526
1527
1528
1529
1530 /*************************************************
1531 *            TLS version of getc                 *
1532 *************************************************/
1533
1534 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1535 it refills the buffer via the GnuTLS reading function.
1536
1537 This feeds DKIM and should be used for all message-body reads.
1538
1539 Arguments:  none
1540 Returns:    the next character or EOF
1541 */
1542
1543 int
1544 tls_getc(void)
1545 {
1546 exim_gnutls_state_st *state = current_global_tls_state;
1547 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
1548   {
1549   ssize_t inbytes;
1550
1551   DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%p, %p, %u)\n",
1552     state->session, state->xfer_buffer, ssl_xfer_buffer_size);
1553
1554   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1555   inbytes = gnutls_record_recv(state->session, state->xfer_buffer,
1556     ssl_xfer_buffer_size);
1557   alarm(0);
1558
1559   /* A zero-byte return appears to mean that the TLS session has been
1560      closed down, not that the socket itself has been closed down. Revert to
1561      non-TLS handling. */
1562
1563   if (inbytes == 0)
1564     {
1565     DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1566
1567     receive_getc = smtp_getc;
1568     receive_ungetc = smtp_ungetc;
1569     receive_feof = smtp_feof;
1570     receive_ferror = smtp_ferror;
1571     receive_smtp_buffered = smtp_buffered;
1572
1573     gnutls_deinit(state->session);
1574     state->session = NULL;
1575     tls_active = -1;
1576     tls_bits = 0;
1577     tls_certificate_verified = FALSE;
1578     tls_channelbinding_b64 = NULL;
1579     tls_cipher = NULL;
1580     tls_peerdn = NULL;
1581
1582     return smtp_getc();
1583     }
1584
1585   /* Handle genuine errors */
1586
1587   else if (inbytes < 0)
1588     {
1589     record_io_error(state, (int) inbytes, US"recv", NULL);
1590     state->xfer_error = 1;
1591     return EOF;
1592     }
1593 #ifndef DISABLE_DKIM
1594   dkim_exim_verify_feed(state->xfer_buffer, inbytes);
1595 #endif
1596   state->xfer_buffer_hwm = (int) inbytes;
1597   state->xfer_buffer_lwm = 0;
1598   }
1599
1600 /* Something in the buffer; return next uschar */
1601
1602 return state->xfer_buffer[state->xfer_buffer_lwm++];
1603 }
1604
1605
1606
1607
1608 /*************************************************
1609 *          Read bytes from TLS channel           *
1610 *************************************************/
1611
1612 /* This does not feed DKIM, so if the caller uses this for reading message body,
1613 then the caller must feed DKIM.
1614 Arguments:
1615   buff      buffer of data
1616   len       size of buffer
1617
1618 Returns:    the number of bytes read
1619             -1 after a failed read
1620 */
1621
1622 int
1623 tls_read(uschar *buff, size_t len)
1624 {
1625 exim_gnutls_state_st *state = current_global_tls_state;
1626 ssize_t inbytes;
1627
1628 if (len > INT_MAX)
1629   len = INT_MAX;
1630
1631 if (state->xfer_buffer_lwm < state->xfer_buffer_hwm)
1632   DEBUG(D_tls)
1633     debug_printf("*** PROBABLY A BUG *** " \
1634         "tls_read() called with data in the tls_getc() buffer, %d ignored\n",
1635         state->xfer_buffer_hwm - state->xfer_buffer_lwm);
1636
1637 DEBUG(D_tls)
1638   debug_printf("Calling gnutls_record_recv(%p, %p, " SIZE_T_FMT ")\n",
1639       state->session, buff, len);
1640
1641 inbytes = gnutls_record_recv(state->session, buff, len);
1642 if (inbytes > 0) return inbytes;
1643 if (inbytes == 0)
1644   {
1645   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1646   }
1647 else record_io_error(state, (int)inbytes, US"recv", NULL);
1648
1649 return -1;
1650 }
1651
1652
1653
1654
1655 /*************************************************
1656 *         Write bytes down TLS channel           *
1657 *************************************************/
1658
1659 /*
1660 Arguments:
1661   buff      buffer of data
1662   len       number of bytes
1663
1664 Returns:    the number of bytes after a successful write,
1665             -1 after a failed write
1666 */
1667
1668 int
1669 tls_write(const uschar *buff, size_t len)
1670 {
1671 ssize_t outbytes;
1672 size_t left = len;
1673 exim_gnutls_state_st *state = current_global_tls_state;
1674
1675 DEBUG(D_tls) debug_printf("tls_do_write(%p, " SIZE_T_FMT ")\n", buff, left);
1676 while (left > 0)
1677   {
1678   DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %p, " SIZE_T_FMT ")\n",
1679       buff, left);
1680   outbytes = gnutls_record_send(state->session, buff, left);
1681
1682   DEBUG(D_tls) debug_printf("outbytes=" SSIZE_T_FMT "\n", outbytes);
1683   if (outbytes < 0)
1684     {
1685     record_io_error(state, outbytes, US"send", NULL);
1686     return -1;
1687     }
1688   if (outbytes == 0)
1689     {
1690     record_io_error(state, 0, US"send", US"TLS channel closed on write");
1691     return -1;
1692     }
1693
1694   left -= outbytes;
1695   buff += outbytes;
1696   }
1697
1698 if (len > INT_MAX)
1699   {
1700   DEBUG(D_tls)
1701     debug_printf("Whoops!  Wrote more bytes (" SIZE_T_FMT ") than INT_MAX\n",
1702         len);
1703   len = INT_MAX;
1704   }
1705
1706 return (int) len;
1707 }
1708
1709
1710
1711
1712 /*************************************************
1713 *            Random number generation            *
1714 *************************************************/
1715
1716 /* Pseudo-random number generation.  The result is not expected to be
1717 cryptographically strong but not so weak that someone will shoot themselves
1718 in the foot using it as a nonce in input in some email header scheme or
1719 whatever weirdness they'll twist this into.  The result should handle fork()
1720 and avoid repeating sequences.  OpenSSL handles that for us.
1721
1722 Arguments:
1723   max       range maximum
1724 Returns     a random number in range [0, max-1]
1725 */
1726
1727 #ifdef HAVE_GNUTLS_RND
1728 int
1729 vaguely_random_number(int max)
1730 {
1731 unsigned int r;
1732 int i, needed_len;
1733 uschar *p;
1734 uschar smallbuf[sizeof(r)];
1735
1736 if (max <= 1)
1737   return 0;
1738
1739 needed_len = sizeof(r);
1740 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
1741  * asked for a number less than 10. */
1742 for (r = max, i = 0; r; ++i)
1743   r >>= 1;
1744 i = (i + 7) / 8;
1745 if (i < needed_len)
1746   needed_len = i;
1747
1748 i = gnutls_rnd(GNUTLS_RND_NONCE, smallbuf, needed_len);
1749 if (i < 0)
1750   {
1751   DEBUG(D_all) debug_printf("gnutls_rnd() failed, using fallback.\n");
1752   return vaguely_random_number_fallback(max);
1753   }
1754 r = 0;
1755 for (p = smallbuf; needed_len; --needed_len, ++p)
1756   {
1757   r *= 256;
1758   r += *p;
1759   }
1760
1761 /* We don't particularly care about weighted results; if someone wants
1762  * smooth distribution and cares enough then they should submit a patch then. */
1763 return r % max;
1764 }
1765 #else /* HAVE_GNUTLS_RND */
1766 int
1767 vaguely_random_number(int max)
1768 {
1769   return vaguely_random_number_fallback(max);
1770 }
1771 #endif /* HAVE_GNUTLS_RND */
1772
1773
1774
1775
1776 /*************************************************
1777 *         Report the library versions.           *
1778 *************************************************/
1779
1780 /* See a description in tls-openssl.c for an explanation of why this exists.
1781
1782 Arguments:   a FILE* to print the results to
1783 Returns:     nothing
1784 */
1785
1786 void
1787 tls_version_report(FILE *f)
1788 {
1789 fprintf(f, "Library version: GnuTLS: Compile: %s\n"
1790            "                         Runtime: %s\n",
1791            LIBGNUTLS_VERSION,
1792            gnutls_check_version(NULL));
1793 }
1794
1795 /* End of tls-gnu.c */