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