1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2012 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Copyright (c) Phil Pennock 2012 */
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.
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
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).
24 Keeping client and server variables more split than before and is currently
25 the norm, in anticipation of TLS in ACL callouts.
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.
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).
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>
46 gnutls_global_set_audit_log_function()
49 gnutls_certificate_verify_peers2(): is new, drop the 2 for old version
52 /* Local static variables for GnuTLS */
54 /* Values for verify_requirement */
56 enum peer_verify_requirement { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED };
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.
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.
66 Not handled here: globals tls_active, tls_bits, tls_cipher, tls_peerdn,
67 tls_certificate_verified, tls_channelbinding_b64, tls_sni.
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;
77 BOOL peer_cert_verified;
78 BOOL trigger_sni_changes;
79 const struct host_item *host;
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;
92 uschar *exp_tls_verify_certificates;
94 uschar *exp_tls_require_ciphers;
102 uschar cipherbuf[256];
103 } exim_gnutls_state_st;
105 static const exim_gnutls_state_st exim_gnutls_state_init = {
106 NULL, NULL, NULL, VERIFY_NONE, -1, -1, FALSE, FALSE,
108 NULL, NULL, NULL, NULL, NULL, NULL,
109 NULL, NULL, NULL, NULL, NULL, NULL,
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. */
123 static exim_gnutls_state_st state_server, state_client;
124 static exim_gnutls_state_st *current_global_tls_state;
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. */
130 static gnutls_dh_params_t dh_server_params = NULL;
132 /* No idea how this value was chosen; preserving it. Default is 3600. */
134 static const int ssl_session_timeout = 200;
136 static const char * const exim_default_gnutls_priority = "NORMAL";
138 /* Guard library core initialisation */
140 static BOOL exim_gnutls_base_init_done = FALSE;
143 /* ------------------------------------------------------------------------ */
144 /* Callback declarations */
146 static void exim_gnutls_logger_cb(int level, const char *message);
147 static int exim_sni_handling_cb(gnutls_session_t session);
149 /* ------------------------------------------------------------------------ */
152 #define MAX_HOST_LEN 255
154 /* Set this to control gnutls_global_set_log_level(); values 0 to 9 will setup
155 the library logging; a value less than 0 disables the calls to set up logging
157 #define EXIM_GNUTLS_LIBRARY_LOG_LEVEL -1
159 #define EXIM_CLIENT_DH_MIN_BITS 1024
161 #define exim_gnutls_err_check(Label) do { \
162 if (rc != GNUTLS_E_SUCCESS) { return tls_error((Label), gnutls_strerror(rc), host); } } while (0)
164 #define exim_gnutls_err_debugreturn0(Label) do { \
165 if (rc != GNUTLS_E_SUCCESS) { \
166 DEBUG(D_tls) debug_printf("TLS failure: %s: %s", (Label), gnutls_strerror(rc)); \
167 return 0; } } while (0)
169 #define expand_check_tlsvar(Varname) expand_check(state->Varname, US #Varname, &state->exp_##Varname)
171 #if GNUTLS_VERSION_NUMBER >= 0x020c00
172 #define HAVE_GNUTLS_SESSION_CHANNEL_BINDING
175 /* ------------------------------------------------------------------------ */
176 /* Static functions */
178 /*************************************************
180 *************************************************/
182 /* Called from lots of places when errors occur before actually starting to do
183 the TLS handshake, that is, while the session is still in clear. Always returns
184 DEFER for a server and FAIL for a client so that most calls can use "return
185 tls_error(...)" to do this processing and then give an appropriate return. A
186 single function is used for both server and client, because it is called from
187 some shared functions.
190 prefix text to include in the logged error
191 msg additional error string (may be NULL)
192 usually obtained from gnutls_strerror()
193 host NULL if setting up a server;
194 the connected host if setting up a client
196 Returns: OK/DEFER/FAIL
200 tls_error(const uschar *prefix, const char *msg, const host_item *host)
204 log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s)%s%s",
205 host->name, host->address, prefix, msg ? ": " : "", msg ? msg : "");
210 uschar *conn_info = smtp_get_connection_info();
211 if (Ustrncmp(conn_info, US"SMTP ", 5) == 0)
213 log_write(0, LOG_MAIN, "TLS error on %s (%s)%s%s",
214 conn_info, prefix, msg ? ": " : "", msg ? msg : "");
222 /*************************************************
223 * Deal with logging errors during I/O *
224 *************************************************/
226 /* We have to get the identity of the peer from saved data.
229 state the current GnuTLS exim state container
230 rc the GnuTLS error code, or 0 if it's a local error
231 when text identifying read or write
232 text local error text when ec is 0
238 record_io_error(exim_gnutls_state_st *state, int rc, uschar *when, uschar *text)
242 if (rc == GNUTLS_E_FATAL_ALERT_RECEIVED)
243 msg = CS string_sprintf("%s: %s", US gnutls_strerror(rc),
244 US gnutls_alert_get_name(gnutls_alert_get(state->session)));
246 msg = gnutls_strerror(rc);
248 tls_error(when, msg, state->host);
254 /*************************************************
255 * Set various Exim expansion vars *
256 *************************************************/
258 /* We set various Exim global variables from the state, once a session has
259 been established. With TLS callouts, may need to change this to stack
260 variables, or just re-call it with the server state after client callout
263 Make sure anything set here is inset in tls_getc().
267 tls_bits strength indicator
268 tls_certificate_verified bool indicator
269 tls_channelbinding_b64 for some SASL mechanisms
272 tls_sni a (UTF-8) string
274 current_global_tls_state for API limitations
277 state the relevant exim_gnutls_state_st *
281 extract_exim_vars_from_tls_state(exim_gnutls_state_st *state)
283 gnutls_protocol_t protocol;
284 gnutls_cipher_algorithm_t cipher;
285 gnutls_kx_algorithm_t kx;
286 gnutls_mac_algorithm_t mac;
288 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
291 gnutls_datum_t channel;
294 current_global_tls_state = state;
296 tls_active = state->fd_out;
298 cipher = gnutls_cipher_get(state->session);
299 /* returns size in "bytes" */
300 tls_bits = gnutls_cipher_get_key_size(cipher) * 8;
302 if (!*state->cipherbuf)
304 protocol = gnutls_protocol_get_version(state->session);
305 mac = gnutls_mac_get(state->session);
306 kx = gnutls_kx_get(state->session);
308 string_format(state->cipherbuf, sizeof(state->cipherbuf),
310 gnutls_protocol_get_name(protocol),
311 gnutls_cipher_suite_get_name(kx, cipher, mac),
314 /* I don't see a way that spaces could occur, in the current GnuTLS
315 code base, but it was a concern in the old code and perhaps older GnuTLS
316 releases did return "TLS 1.0"; play it safe, just in case. */
317 for (p = state->cipherbuf; *p != '\0'; ++p)
321 tls_cipher = state->cipherbuf;
323 DEBUG(D_tls) debug_printf("cipher: %s\n", tls_cipher);
325 tls_certificate_verified = state->peer_cert_verified;
327 /* note that tls_channelbinding_b64 is not saved to the spool file, since it's
328 only available for use for authenticators while this TLS session is running. */
330 tls_channelbinding_b64 = NULL;
331 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
334 rc = gnutls_session_channel_binding(state->session, GNUTLS_CB_TLS_UNIQUE, &channel);
336 DEBUG(D_tls) debug_printf("Channel binding error: %s\n", gnutls_strerror(rc));
338 old_pool = store_pool;
339 store_pool = POOL_PERM;
340 tls_channelbinding_b64 = auth_b64encode(channel.data, (int)channel.size);
341 store_pool = old_pool;
342 DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage.\n");
346 tls_peerdn = state->peerdn;
348 tls_sni = state->received_sni;
354 /*************************************************
355 * Setup up DH parameters *
356 *************************************************/
358 /* Generating the D-H parameters may take a long time. They only need to
359 be re-generated every so often, depending on security policy. What we do is to
360 keep these parameters in a file in the spool directory. If the file does not
361 exist, we generate them. This means that it is easy to cause a regeneration.
363 The new file is written as a temporary file and renamed, so that an incomplete
364 file is never present. If two processes both compute some new parameters, you
365 waste a bit of effort, but it doesn't seem worth messing around with locking to
369 host NULL for server, server for client (for error handling)
371 Returns: OK/DEFER/FAIL
378 unsigned int dh_bits;
380 uschar filename[PATH_MAX];
382 host_item *host = NULL; /* dummy for macros */
383 const char * const dh_param_fn_ext = "normal"; /* change as dh_bits changes */
385 DEBUG(D_tls) debug_printf("Initialising GnuTLS server params.\n");
387 rc = gnutls_dh_params_init(&dh_server_params);
388 exim_gnutls_err_check(US"gnutls_dh_params_init");
390 /* If you change this, also change dh_param_fn_ext so that we can use a
391 different filename and ensure we have sufficient bits. */
392 dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, GNUTLS_SEC_PARAM_NORMAL);
394 return tls_error(US"gnutls_sec_param_to_pk_bits() failed", NULL, NULL);
396 if (!string_format(filename, sizeof(filename),
397 "%s/gnutls-params-%s", spool_directory, dh_param_fn_ext))
398 return tls_error(US"overlong filename", NULL, NULL);
400 /* Open the cache file for reading and if successful, read it and set up the
403 fd = Uopen(filename, O_RDONLY, 0);
410 if (fstat(fd, &statbuf) < 0) /* EIO */
414 return tls_error(US"TLS cache stat failed", strerror(saved_errno), NULL);
416 if (!S_ISREG(statbuf.st_mode))
419 return tls_error(US"TLS cache not a file", NULL, NULL);
421 fp = fdopen(fd, "rb");
426 return tls_error(US"fdopen(TLS cache stat fd) failed",
427 strerror(saved_errno), NULL);
430 m.size = statbuf.st_size;
431 m.data = malloc(m.size);
435 return tls_error(US"malloc failed", strerror(errno), NULL);
437 sz = fread(m.data, m.size, 1, fp);
443 return tls_error(US"fread failed", strerror(saved_errno), NULL);
447 rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM);
449 exim_gnutls_err_check(US"gnutls_dh_params_import_pkcs3");
450 DEBUG(D_tls) debug_printf("read D-H parameters from file \"%s\"\n", filename);
453 /* If the file does not exist, fall through to compute new data and cache it.
454 If there was any other opening error, it is serious. */
456 else if (errno == ENOENT)
460 debug_printf("D-H parameter cache file \"%s\" does not exist\n", filename);
463 return tls_error(string_open_failed(errno, "\"%s\" for reading", filename),
466 /* If ret < 0, either the cache file does not exist, or the data it contains
467 is not useful. One particular case of this is when upgrading from an older
468 release of Exim in which the data was stored in a different format. We don't
469 try to be clever and support both formats; we just regenerate new data in this
476 if ((PATH_MAX - Ustrlen(filename)) < 10)
477 return tls_error(US"Filename too long to generate replacement",
480 temp_fn = string_copy(US "%s.XXXXXXX");
481 fd = mkstemp(CS temp_fn); /* modifies temp_fn */
483 return tls_error(US"Unable to open temp file", strerror(errno), NULL);
484 (void)fchown(fd, exim_uid, exim_gid); /* Probably not necessary */
486 DEBUG(D_tls) debug_printf("generating %d bits Diffie-Hellman key ...\n", dh_bits);
487 rc = gnutls_dh_params_generate2(dh_server_params, dh_bits);
488 exim_gnutls_err_check(US"gnutls_dh_params_generate2");
490 /* gnutls_dh_params_export_pkcs3() will tell us the exact size, every time,
491 and I confirmed that a NULL call to get the size first is how the GnuTLS
492 sample apps handle this. */
496 rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
498 if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
499 exim_gnutls_err_check(US"gnutls_dh_params_export_pkcs3(NULL) sizing");
501 m.data = malloc(m.size);
503 return tls_error(US"memory allocation failed", strerror(errno), NULL);
504 rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
506 if (rc != GNUTLS_E_SUCCESS)
509 exim_gnutls_err_check(US"gnutls_dh_params_export_pkcs3() real");
512 sz = write_to_fd_buf(fd, m.data, (size_t) m.size);
516 return tls_error(US"TLS cache write D-H params failed",
517 strerror(errno), NULL);
520 sz = write_to_fd_buf(fd, US"\n", 1);
522 return tls_error(US"TLS cache write D-H params final newline failed",
523 strerror(errno), NULL);
527 return tls_error(US"TLS cache write close() failed",
528 strerror(errno), NULL);
530 if (Urename(temp_fn, filename) < 0)
531 return tls_error(string_sprintf("failed to rename \"%s\" as \"%s\"",
532 temp_fn, filename), strerror(errno), NULL);
534 DEBUG(D_tls) debug_printf("wrote D-H parameters to file \"%s\"\n", filename);
537 DEBUG(D_tls) debug_printf("initialized server D-H parameters\n");
544 /*************************************************
545 * Variables re-expanded post-SNI *
546 *************************************************/
548 /* Called from both server and client code, via tls_init(), and also from
549 the SNI callback after receiving an SNI, if tls_certificate includes "tls_sni".
551 We can tell the two apart by state->received_sni being non-NULL in callback.
553 The callback should not call us unless state->trigger_sni_changes is true,
554 which we are responsible for setting on the first pass through.
557 state exim_gnutls_state_st *
559 Returns: OK/DEFER/FAIL
563 tls_expand_session_files(exim_gnutls_state_st *state)
566 const host_item *host = state->host; /* macro should be reconsidered? */
567 uschar *saved_tls_certificate = NULL;
568 uschar *saved_tls_privatekey = NULL;
569 uschar *saved_tls_verify_certificates = NULL;
570 uschar *saved_tls_crl = NULL;
573 /* We check for tls_sni *before* expansion. */
576 if (!state->received_sni)
578 if (Ustrstr(state->tls_certificate, US"tls_sni"))
580 DEBUG(D_tls) debug_printf("We will re-expand TLS session files if we receive SNI.\n");
581 state->trigger_sni_changes = TRUE;
586 saved_tls_certificate = state->exp_tls_certificate;
587 saved_tls_privatekey = state->exp_tls_privatekey;
588 saved_tls_verify_certificates = state->exp_tls_verify_certificates;
589 saved_tls_crl = state->exp_tls_crl;
593 /* remember: expand_check_tlsvar() is expand_check() but fiddling with
594 state members, assuming consistent naming; and expand_check() returns
595 false if expansion failed, unless expansion was forced to fail. */
597 /* check if we at least have a certificate, before doing expensive
600 if (!expand_check_tlsvar(tls_certificate))
603 /* certificate is mandatory in server, optional in client */
605 if ((state->exp_tls_certificate == NULL) ||
606 (*state->exp_tls_certificate == '\0'))
608 if (state->host == NULL)
609 return tls_error(US"no TLS server certificate is specified", NULL, NULL);
611 DEBUG(D_tls) debug_printf("TLS: no client certificate specified; okay\n");
614 if (state->tls_privatekey && !expand_check_tlsvar(tls_privatekey))
617 /* tls_privatekey is optional, defaulting to same file as certificate */
619 if (state->tls_privatekey == NULL || *state->tls_privatekey == '\0')
621 state->tls_privatekey = state->tls_certificate;
622 state->exp_tls_privatekey = state->exp_tls_certificate;
626 if (state->exp_tls_certificate && *state->exp_tls_certificate)
629 DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
630 state->exp_tls_certificate, state->exp_tls_privatekey);
632 if (state->received_sni)
634 if ((Ustrcmp(state->exp_tls_certificate, saved_tls_certificate) == 0) &&
635 (Ustrcmp(state->exp_tls_privatekey, saved_tls_privatekey) == 0))
637 DEBUG(D_tls) debug_printf("cert and key unchanged with SNI.\n");
642 DEBUG(D_tls) debug_printf("SNI changed cert/key pair.\n");
648 rc = gnutls_certificate_set_x509_key_file(state->x509_cred,
649 CS state->exp_tls_certificate, CS state->exp_tls_privatekey,
650 GNUTLS_X509_FMT_PEM);
651 exim_gnutls_err_check(
652 string_sprintf("cert/key setup: cert=%s key=%s",
653 state->exp_tls_certificate, state->exp_tls_privatekey));
657 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
658 provided. Experiment shows that, if the certificate file is empty, an unhelpful
659 error message is provided. However, if we just refrain from setting anything up
660 in that case, certificate verification fails, which seems to be the correct
663 if (state->tls_verify_certificates && *state->tls_verify_certificates)
666 BOOL setit_vc = TRUE, setit_crl = TRUE;
668 if (!expand_check_tlsvar(tls_verify_certificates))
670 if (state->tls_crl && *state->tls_crl)
671 if (!expand_check_tlsvar(tls_crl))
674 if (state->received_sni)
676 if (Ustrcmp(state->exp_tls_verify_certificates, saved_tls_verify_certificates) == 0)
678 if (Ustrcmp(state->exp_tls_crl, saved_tls_crl) == 0)
682 /* nb: early exit; change if add more expansions to this function */
683 if (!(setit_vc || setit_crl))
686 if (Ustat(state->exp_tls_verify_certificates, &statbuf) < 0)
688 log_write(0, LOG_MAIN|LOG_PANIC, "could not stat %s "
689 "(tls_verify_certificates): %s", state->exp_tls_verify_certificates,
694 if (!S_ISREG(statbuf.st_mode))
697 debug_printf("verify certificates path is not a file: \"%s\"\n%s\n",
698 state->exp_tls_verify_certificates,
699 S_ISDIR(statbuf.st_mode)
700 ? " it's a directory, that's OpenSSL, this is GnuTLS"
701 : " (not a directory either)");
702 log_write(0, LOG_MAIN|LOG_PANIC,
703 "tls_verify_certificates \"%s\" is not a file",
704 state->exp_tls_verify_certificates);
708 DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
709 state->exp_tls_verify_certificates, statbuf.st_size);
711 /* If the CA cert file is empty, there's no point in loading the CRL file,
712 as we aren't verifying, so checking for revocation is pointless. */
714 if (statbuf.st_size > 0)
718 cert_count = gnutls_certificate_set_x509_trust_file(state->x509_cred,
719 CS state->exp_tls_verify_certificates, GNUTLS_X509_FMT_PEM);
723 exim_gnutls_err_check(US"gnutls_certificate_set_x509_trust_file");
725 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n", cert_count);
728 if (setit_crl && state->tls_crl && *state->tls_crl)
730 if (state->exp_tls_crl && *state->exp_tls_crl)
732 DEBUG(D_tls) debug_printf("loading CRL file = %s\n", state->exp_tls_crl);
733 rc = gnutls_certificate_set_x509_crl_file(state->x509_cred,
734 CS state->exp_tls_crl, GNUTLS_X509_FMT_PEM);
735 exim_gnutls_err_check(US"gnutls_certificate_set_x509_crl_file");
738 } /* statbuf.st_size */
739 } /* tls_verify_certificates */
742 /* also above, during verify_certificates/crl, during SNI, if unchanged */
748 /*************************************************
749 * Initialize for GnuTLS *
750 *************************************************/
752 /* Called from both server and client code. In the case of a server, errors
753 before actual TLS negotiation return DEFER.
756 host connected host, if client; NULL if server
757 certificate certificate file
758 privatekey private key file
759 sni TLS SNI to send, sometimes when client; else NULL
762 require_ciphers tls_require_ciphers setting
764 Returns: OK/DEFER/FAIL
769 const host_item *host,
770 const uschar *certificate,
771 const uschar *privatekey,
775 const uschar *require_ciphers,
776 exim_gnutls_state_st **caller_state)
778 exim_gnutls_state_st *state;
783 BOOL want_default_priorities;
785 if (!exim_gnutls_base_init_done)
787 DEBUG(D_tls) debug_printf("GnuTLS global init required.\n");
789 rc = gnutls_global_init();
790 exim_gnutls_err_check(US"gnutls_global_init");
792 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
795 gnutls_global_set_log_function(exim_gnutls_logger_cb);
796 /* arbitrarily chosen level; bump upto 9 for more */
797 gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL);
801 exim_gnutls_base_init_done = TRUE;
806 state = &state_client;
807 memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
808 DEBUG(D_tls) debug_printf("initialising GnuTLS client session\n");
809 rc = gnutls_init(&state->session, GNUTLS_CLIENT);
813 state = &state_server;
814 memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
815 DEBUG(D_tls) debug_printf("initialising GnuTLS server session\n");
816 rc = gnutls_init(&state->session, GNUTLS_SERVER);
818 exim_gnutls_err_check(US"gnutls_init");
822 state->tls_certificate = certificate;
823 state->tls_privatekey = privatekey;
824 state->tls_sni = sni;
825 state->tls_verify_certificates = cas;
826 state->tls_crl = crl;
828 rc = gnutls_certificate_allocate_credentials(&state->x509_cred);
829 exim_gnutls_err_check(US"gnutls_certificate_allocate_credentials");
831 /* This handles the variables that might get re-expanded after TLS SNI;
832 that's tls_certificate, tls_privatekey, tls_verify_certificates, tls_crl */
835 debug_printf("Expanding various TLS configuration options for session credentials.\n");
836 rc = tls_expand_session_files(state);
837 if (rc != OK) return rc;
839 /* Create D-H parameters, or read them from the cache file. This function does
840 its own SMTP error messaging. This only happens for the server, TLS D-H ignores
841 client-side params. */
845 rc = init_server_dh();
846 if (rc != OK) return rc;
847 gnutls_certificate_set_dh_params(state->x509_cred, dh_server_params);
850 /* Link the credentials to the session. */
852 rc = gnutls_credentials_set(state->session, GNUTLS_CRD_CERTIFICATE, state->x509_cred);
853 exim_gnutls_err_check(US"gnutls_credentials_set");
855 /* set SNI in client, only */
858 if (!expand_check_tlsvar(tls_sni))
860 if (state->exp_tls_sni && *state->exp_tls_sni)
863 debug_printf("Setting TLS client SNI to \"%s\"\n", state->exp_tls_sni);
864 sz = Ustrlen(state->exp_tls_sni);
865 rc = gnutls_server_name_set(state->session,
866 GNUTLS_NAME_DNS, state->exp_tls_sni, sz);
867 exim_gnutls_err_check(US"gnutls_server_name_set");
870 else if (state->tls_sni)
871 DEBUG(D_tls) debug_printf("*** PROBABLY A BUG *** " \
872 "have an SNI set for a client [%s]\n", state->tls_sni);
874 /* This is the priority string support,
875 http://www.gnu.org/software/gnutls/manual/html_node/Priority-Strings.html
876 and replaces gnutls_require_kx, gnutls_require_mac & gnutls_require_protocols.
877 This was backwards incompatible, but means Exim no longer needs to track
878 all algorithms and provide string forms for them. */
880 want_default_priorities = TRUE;
882 if (state->tls_require_ciphers && *state->tls_require_ciphers)
884 if (!expand_check_tlsvar(tls_require_ciphers))
886 if (state->exp_tls_require_ciphers && *state->exp_tls_require_ciphers)
888 DEBUG(D_tls) debug_printf("GnuTLS session cipher/priority \"%s\"\n",
889 state->exp_tls_require_ciphers);
891 rc = gnutls_priority_init(&state->priority_cache,
892 CS state->exp_tls_require_ciphers, &errpos);
893 want_default_priorities = FALSE;
894 p = state->exp_tls_require_ciphers;
897 if (want_default_priorities)
899 rc = gnutls_priority_init(&state->priority_cache,
900 exim_default_gnutls_priority, &errpos);
901 p = US exim_default_gnutls_priority;
904 exim_gnutls_err_check(string_sprintf(
905 "gnutls_priority_init(%s) failed at offset %ld, \"%.6s..\"",
906 p, errpos - CS p, errpos));
908 rc = gnutls_priority_set(state->session, state->priority_cache);
909 exim_gnutls_err_check(US"gnutls_priority_set");
911 gnutls_db_set_cache_expiration(state->session, ssl_session_timeout);
913 /* Reduce security in favour of increased compatibility, if the admin
914 decides to make that trade-off. */
915 if (gnutls_compat_mode)
917 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
918 DEBUG(D_tls) debug_printf("lowering GnuTLS security, compatibility mode\n");
919 gnutls_session_enable_compatibility_mode(state->session);
921 DEBUG(D_tls) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
925 *caller_state = state;
926 /* needs to happen before callbacks during handshake */
927 current_global_tls_state = state;
934 /*************************************************
935 * Extract peer information *
936 *************************************************/
938 /* Called from both server and client code.
939 Only this is allowed to set state->peerdn and we use that to detect double-calls.
942 state exim_gnutls_state_st *
944 Returns: OK/DEFER/FAIL
948 peer_status(exim_gnutls_state_st *state)
950 const gnutls_datum *cert_list;
952 unsigned int cert_list_size = 0;
953 gnutls_certificate_type_t ct;
954 gnutls_x509_crt_t crt;
961 state->peerdn = US"unknown";
963 cert_list = gnutls_certificate_get_peers(state->session, &cert_list_size);
965 if (cert_list == NULL || cert_list_size == 0)
967 state->peerdn = US"unknown (no certificate)";
968 DEBUG(D_tls) debug_printf("TLS: no certificate from peer (%p & %d)\n",
969 cert_list, cert_list_size);
970 if (state->verify_requirement == VERIFY_REQUIRED)
971 return tls_error(US"certificate verification failed",
972 "no certificate received from peer", state->host);
976 ct = gnutls_certificate_type_get(state->session);
977 if (ct != GNUTLS_CRT_X509)
979 const char *ctn = gnutls_certificate_type_get_name(ct);
980 state->peerdn = string_sprintf("unknown (type %s)", ctn);
982 debug_printf("TLS: peer cert not X.509 but instead \"%s\"\n", ctn);
983 if (state->verify_requirement == VERIFY_REQUIRED)
984 return tls_error(US"certificate verification not possible, unhandled type",
989 #define exim_gnutls_peer_err(Label) do { \
990 if (rc != GNUTLS_E_SUCCESS) { \
991 DEBUG(D_tls) debug_printf("TLS: peer cert problem: %s: %s\n", (Label), gnutls_strerror(rc)); \
992 if (state->verify_requirement == VERIFY_REQUIRED) { return tls_error((Label), gnutls_strerror(rc), state->host); } \
993 return OK; } } while (0)
995 rc = gnutls_x509_crt_init(&crt);
996 exim_gnutls_peer_err(US"gnutls_x509_crt_init (crt)");
998 rc = gnutls_x509_crt_import(crt, &cert_list[0], GNUTLS_X509_FMT_DER);
999 exim_gnutls_peer_err(US"failed to import certificate [gnutls_x509_crt_import(cert 0)]");
1001 rc = gnutls_x509_crt_get_dn(crt, NULL, &sz);
1002 if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
1004 exim_gnutls_peer_err(US"getting size for cert DN failed");
1005 return FAIL; /* should not happen */
1007 dn_buf = store_get_perm(sz);
1008 rc = gnutls_x509_crt_get_dn(crt, CS dn_buf, &sz);
1009 exim_gnutls_peer_err(US"failed to extract certificate DN [gnutls_x509_crt_get_dn(cert 0)]");
1010 state->peerdn = dn_buf;
1013 #undef exim_gnutls_peer_err
1019 /*************************************************
1020 * Verify peer certificate *
1021 *************************************************/
1023 /* Called from both server and client code.
1024 *Should* be using a callback registered with
1025 gnutls_certificate_set_verify_function() to fail the handshake if we dislike
1026 the peer information, but that's too new for some OSes.
1029 state exim_gnutls_state_st *
1030 error where to put an error message
1033 FALSE if the session should be rejected
1034 TRUE if the cert is okay or we just don't care
1038 verify_certificate(exim_gnutls_state_st *state, const char **error)
1041 unsigned int verify;
1045 rc = peer_status(state);
1048 verify = GNUTLS_CERT_INVALID;
1049 *error = "not supplied";
1053 rc = gnutls_certificate_verify_peers2(state->session, &verify);
1056 /* Handle the result of verification. INVALID seems to be set as well
1057 as REVOKED, but leave the test for both. */
1059 if ((rc < 0) || (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED)) != 0)
1061 state->peer_cert_verified = FALSE;
1063 *error = ((verify & GNUTLS_CERT_REVOKED) != 0) ? "revoked" : "invalid";
1066 debug_printf("TLS certificate verification failed (%s): peerdn=%s\n",
1067 *error, state->peerdn);
1069 if (state->verify_requirement == VERIFY_REQUIRED)
1071 gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
1075 debug_printf("TLS verify failure overriden (host in tls_try_verify_hosts)\n");
1079 state->peer_cert_verified = TRUE;
1080 DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=%s\n", state->peerdn);
1083 tls_peerdn = state->peerdn;
1091 /* ------------------------------------------------------------------------ */
1094 /* Logging function which can be registered with
1095 * gnutls_global_set_log_function()
1096 * gnutls_global_set_log_level() 0..9
1099 exim_gnutls_logger_cb(int level, const char *message)
1101 DEBUG(D_tls) debug_printf("GnuTLS<%d>: %s\n", level, message);
1105 /* Called after client hello, should handle SNI work.
1106 This will always set tls_sni (state->received_sni) if available,
1107 and may trigger presenting different certificates,
1108 if state->trigger_sni_changes is TRUE.
1110 Should be registered with
1111 gnutls_handshake_set_post_client_hello_function()
1113 "This callback must return 0 on success or a gnutls error code to terminate the
1116 For inability to get SNI information, we return 0.
1117 We only return non-zero if re-setup failed.
1121 exim_sni_handling_cb(gnutls_session_t session)
1123 char sni_name[MAX_HOST_LEN];
1124 size_t data_len = MAX_HOST_LEN;
1125 exim_gnutls_state_st *state = current_global_tls_state;
1126 unsigned int sni_type;
1129 rc = gnutls_server_name_get(session, sni_name, &data_len, &sni_type, 0);
1130 exim_gnutls_err_debugreturn0("gnutls_server_name_get()");
1131 if (sni_type != GNUTLS_NAME_DNS)
1133 DEBUG(D_tls) debug_printf("TLS: ignoring SNI of unhandled type %u\n", sni_type);
1137 /* We now have a UTF-8 string in sni_name */
1138 old_pool = store_pool;
1139 store_pool = POOL_PERM;
1140 state->received_sni = string_copyn(US sni_name, data_len);
1141 store_pool = old_pool;
1143 /* We set this one now so that variable expansions below will work */
1144 tls_sni = state->received_sni;
1146 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", sni_name,
1147 state->trigger_sni_changes ? "" : " (unused for certificate selection)");
1149 if (!state->trigger_sni_changes)
1152 rc = tls_expand_session_files(state);
1155 /* If the setup of certs/etc failed before handshake, TLS would not have
1156 been offered. The best we can do now is abort. */
1157 return GNUTLS_E_APPLICATION_ERROR_MIN;
1160 rc = gnutls_credentials_set(state->session, GNUTLS_CRD_CERTIFICATE, state->x509_cred);
1161 return (rc == GNUTLS_E_SUCCESS) ? 0 : rc;
1167 /* ------------------------------------------------------------------------ */
1168 /* Exported functions */
1173 /*************************************************
1174 * Start a TLS session in a server *
1175 *************************************************/
1177 /* This is called when Exim is running as a server, after having received
1178 the STARTTLS command. It must respond to that command, and then negotiate
1182 require_ciphers list of allowed ciphers or NULL
1184 Returns: OK on success
1185 DEFER for errors before the start of the negotiation
1186 FAIL for errors during the negotation; the server can't
1191 tls_server_start(const uschar *require_ciphers)
1195 exim_gnutls_state_st *state = NULL;
1197 /* Check for previous activation */
1198 /* nb: this will not be TLS callout safe, needs reworking as part of that. */
1200 if (tls_active >= 0)
1202 tls_error(US"STARTTLS received after TLS started", "", NULL);
1203 smtp_printf("554 Already in TLS\r\n");
1207 /* Initialize the library. If it fails, it will already have logged the error
1208 and sent an SMTP response. */
1210 DEBUG(D_tls) debug_printf("initialising GnuTLS as a server\n");
1212 rc = tls_init(NULL, tls_certificate, tls_privatekey,
1213 NULL, tls_verify_certificates, tls_crl,
1214 require_ciphers, &state);
1215 if (rc != OK) return rc;
1217 /* If this is a host for which certificate verification is mandatory or
1218 optional, set up appropriately. */
1220 if (verify_check_host(&tls_verify_hosts) == OK)
1222 DEBUG(D_tls) debug_printf("TLS: a client certificate will be required.\n");
1223 state->verify_requirement = VERIFY_REQUIRED;
1224 gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
1226 else if (verify_check_host(&tls_try_verify_hosts) == OK)
1228 DEBUG(D_tls) debug_printf("TLS: a client certificate will be requested but not required.\n");
1229 state->verify_requirement = VERIFY_OPTIONAL;
1230 gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
1234 DEBUG(D_tls) debug_printf("TLS: a client certificate will not be requested.\n");
1235 state->verify_requirement = VERIFY_NONE;
1236 gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
1239 /* Register SNI handling; always, even if not in tls_certificate, so that the
1240 expansion variable $tls_sni is always available. */
1242 gnutls_handshake_set_post_client_hello_function(state->session,
1243 exim_sni_handling_cb);
1245 /* Set context and tell client to go ahead, except in the case of TLS startup
1246 on connection, where outputting anything now upsets the clients and tends to
1247 make them disconnect. We need to have an explicit fflush() here, to force out
1248 the response. Other smtp_printf() calls do not need it, because in non-TLS
1249 mode, the fflush() happens when smtp_getc() is called. */
1251 if (!tls_on_connect)
1253 smtp_printf("220 TLS go ahead\r\n");
1257 /* Now negotiate the TLS session. We put our own timer on it, since it seems
1258 that the GnuTLS library doesn't. */
1260 gnutls_transport_set_ptr2(state->session,
1261 (gnutls_transport_ptr)fileno(smtp_in),
1262 (gnutls_transport_ptr)fileno(smtp_out));
1263 state->fd_in = fileno(smtp_in);
1264 state->fd_out = fileno(smtp_out);
1266 sigalrm_seen = FALSE;
1267 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1270 rc = gnutls_handshake(state->session);
1271 } while ((rc == GNUTLS_E_AGAIN) || (rc == GNUTLS_E_INTERRUPTED));
1274 if (rc != GNUTLS_E_SUCCESS)
1276 tls_error(US"gnutls_handshake",
1277 sigalrm_seen ? "timed out" : gnutls_strerror(rc), NULL);
1278 /* It seems that, except in the case of a timeout, we have to close the
1279 connection right here; otherwise if the other end is running OpenSSL it hangs
1280 until the server times out. */
1284 (void)fclose(smtp_out);
1285 (void)fclose(smtp_in);
1291 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
1293 /* Verify after the fact */
1295 if (state->verify_requirement != VERIFY_NONE)
1297 if (!verify_certificate(state, &error))
1299 if (state->verify_requirement == VERIFY_OPTIONAL)
1302 debug_printf("TLS: continuing on only because verification was optional, after: %s\n",
1307 tls_error(US"certificate verification failed", error, NULL);
1313 /* Figure out peer DN, and if authenticated, etc. */
1315 rc = peer_status(state);
1316 if (rc != OK) return rc;
1318 /* Sets various Exim expansion variables; always safe within server */
1320 extract_exim_vars_from_tls_state(state);
1322 /* TLS has been set up. Adjust the input functions to read via TLS,
1323 and initialize appropriately. */
1325 state->xfer_buffer = store_malloc(ssl_xfer_buffer_size);
1327 receive_getc = tls_getc;
1328 receive_ungetc = tls_ungetc;
1329 receive_feof = tls_feof;
1330 receive_ferror = tls_ferror;
1331 receive_smtp_buffered = tls_smtp_buffered;
1339 /*************************************************
1340 * Start a TLS session in a client *
1341 *************************************************/
1343 /* Called from the smtp transport after STARTTLS has been accepted.
1346 fd the fd of the connection
1347 host connected host (for messages)
1348 addr the first address (not used)
1349 dhparam DH parameter file (ignored, we're a client)
1350 certificate certificate file
1351 privatekey private key file
1352 sni TLS SNI to send to remote host
1353 verify_certs file for certificate verify
1354 verify_crl CRL for verify
1355 require_ciphers list of allowed ciphers or NULL
1356 timeout startup timeout
1358 Returns: OK/DEFER/FAIL (because using common functions),
1359 but for a client, DEFER and FAIL have the same meaning
1363 tls_client_start(int fd, host_item *host,
1364 address_item *addr ARG_UNUSED, uschar *dhparam ARG_UNUSED,
1365 uschar *certificate, uschar *privatekey, uschar *sni,
1366 uschar *verify_certs, uschar *verify_crl,
1367 uschar *require_ciphers, int timeout)
1371 exim_gnutls_state_st *state = NULL;
1373 DEBUG(D_tls) debug_printf("initialising GnuTLS as a client on fd %d\n", fd);
1375 rc = tls_init(host, certificate, privatekey,
1376 sni, verify_certs, verify_crl, require_ciphers, &state);
1377 if (rc != OK) return rc;
1379 gnutls_dh_set_prime_bits(state->session, EXIM_CLIENT_DH_MIN_BITS);
1381 if (verify_certs == NULL)
1383 DEBUG(D_tls) debug_printf("TLS: server certificate verification not required\n");
1384 state->verify_requirement = VERIFY_NONE;
1385 /* we still ask for it, to log it, etc */
1386 gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
1390 DEBUG(D_tls) debug_printf("TLS: server certificate verification required\n");
1391 state->verify_requirement = VERIFY_REQUIRED;
1392 gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
1395 gnutls_transport_set_ptr(state->session, (gnutls_transport_ptr)fd);
1399 /* There doesn't seem to be a built-in timeout on connection. */
1401 sigalrm_seen = FALSE;
1405 rc = gnutls_handshake(state->session);
1406 } while ((rc == GNUTLS_E_AGAIN) || (rc == GNUTLS_E_INTERRUPTED));
1409 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
1413 if (state->verify_requirement != VERIFY_NONE &&
1414 !verify_certificate(state, &error))
1415 return tls_error(US"certificate verification failed", error, state->host);
1417 /* Figure out peer DN, and if authenticated, etc. */
1419 rc = peer_status(state);
1420 if (rc != OK) return rc;
1422 /* Sets various Exim expansion variables; always safe within server */
1424 extract_exim_vars_from_tls_state(state);
1432 /*************************************************
1433 * Close down a TLS session *
1434 *************************************************/
1436 /* This is also called from within a delivery subprocess forked from the
1437 daemon, to shut down the TLS library, without actually doing a shutdown (which
1438 would tamper with the TLS session in the parent process).
1440 Arguments: TRUE if gnutls_bye is to be called
1445 tls_close(BOOL shutdown)
1447 exim_gnutls_state_st *state = current_global_tls_state;
1449 if (tls_active < 0) return; /* TLS was not active */
1453 DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS\n");
1454 gnutls_bye(state->session, GNUTLS_SHUT_WR);
1457 gnutls_deinit(state->session);
1459 memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
1461 if ((state_server.session == NULL) && (state_client.session == NULL))
1463 gnutls_global_deinit();
1464 exim_gnutls_base_init_done = FALSE;
1473 /*************************************************
1474 * TLS version of getc *
1475 *************************************************/
1477 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1478 it refills the buffer via the GnuTLS reading function.
1480 This feeds DKIM and should be used for all message-body reads.
1483 Returns: the next character or EOF
1489 exim_gnutls_state_st *state = current_global_tls_state;
1490 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
1494 DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%p, %p, %u)\n",
1495 state->session, state->xfer_buffer, ssl_xfer_buffer_size);
1497 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1498 inbytes = gnutls_record_recv(state->session, state->xfer_buffer,
1499 ssl_xfer_buffer_size);
1502 /* A zero-byte return appears to mean that the TLS session has been
1503 closed down, not that the socket itself has been closed down. Revert to
1504 non-TLS handling. */
1508 DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1510 receive_getc = smtp_getc;
1511 receive_ungetc = smtp_ungetc;
1512 receive_feof = smtp_feof;
1513 receive_ferror = smtp_ferror;
1514 receive_smtp_buffered = smtp_buffered;
1516 gnutls_deinit(state->session);
1517 state->session = NULL;
1520 tls_certificate_verified = FALSE;
1521 tls_channelbinding_b64 = NULL;
1528 /* Handle genuine errors */
1530 else if (inbytes < 0)
1532 record_io_error(state, (int) inbytes, US"recv", NULL);
1533 state->xfer_error = 1;
1536 #ifndef DISABLE_DKIM
1537 dkim_exim_verify_feed(state->xfer_buffer, inbytes);
1539 state->xfer_buffer_hwm = (int) inbytes;
1540 state->xfer_buffer_lwm = 0;
1543 /* Something in the buffer; return next uschar */
1545 return state->xfer_buffer[state->xfer_buffer_lwm++];
1551 /*************************************************
1552 * Read bytes from TLS channel *
1553 *************************************************/
1555 /* This does not feed DKIM, so if the caller uses this for reading message body,
1556 then the caller must feed DKIM.
1561 Returns: the number of bytes read
1562 -1 after a failed read
1566 tls_read(uschar *buff, size_t len)
1568 exim_gnutls_state_st *state = current_global_tls_state;
1574 if (state->xfer_buffer_lwm < state->xfer_buffer_hwm)
1576 debug_printf("*** PROBABLY A BUG *** " \
1577 "tls_read() called with data in the tls_getc() buffer, %d ignored\n",
1578 state->xfer_buffer_hwm - state->xfer_buffer_lwm);
1581 debug_printf("Calling gnutls_record_recv(%p, %p, " SIZE_T_FMT ")\n",
1582 state->session, buff, len);
1584 inbytes = gnutls_record_recv(state->session, buff, len);
1585 if (inbytes > 0) return inbytes;
1588 DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1590 else record_io_error(state, (int)inbytes, US"recv", NULL);
1598 /*************************************************
1599 * Write bytes down TLS channel *
1600 *************************************************/
1607 Returns: the number of bytes after a successful write,
1608 -1 after a failed write
1612 tls_write(const uschar *buff, size_t len)
1616 exim_gnutls_state_st *state = current_global_tls_state;
1618 DEBUG(D_tls) debug_printf("tls_do_write(%p, " SIZE_T_FMT ")\n", buff, left);
1621 DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %p, " SIZE_T_FMT ")\n",
1623 outbytes = gnutls_record_send(state->session, buff, left);
1625 DEBUG(D_tls) debug_printf("outbytes=" SSIZE_T_FMT "\n", outbytes);
1628 record_io_error(state, outbytes, US"send", NULL);
1633 record_io_error(state, 0, US"send", US"TLS channel closed on write");
1644 debug_printf("Whoops! Wrote more bytes (" SIZE_T_FMT ") than INT_MAX\n",
1655 /*************************************************
1656 * Random number generation *
1657 *************************************************/
1659 /* Pseudo-random number generation. The result is not expected to be
1660 cryptographically strong but not so weak that someone will shoot themselves
1661 in the foot using it as a nonce in input in some email header scheme or
1662 whatever weirdness they'll twist this into. The result should handle fork()
1663 and avoid repeating sequences. OpenSSL handles that for us.
1667 Returns a random number in range [0, max-1]
1671 vaguely_random_number(int max)
1676 uschar smallbuf[sizeof(r)];
1681 needed_len = sizeof(r);
1682 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
1683 * asked for a number less than 10. */
1684 for (r = max, i = 0; r; ++i)
1690 i = gnutls_rnd(GNUTLS_RND_NONCE, smallbuf, needed_len);
1693 DEBUG(D_all) debug_printf("gnutls_rnd() failed, using fallback.\n");
1694 return vaguely_random_number_fallback(max);
1697 for (p = smallbuf; needed_len; --needed_len, ++p)
1703 /* We don't particularly care about weighted results; if someone wants
1704 * smooth distribution and cares enough then they should submit a patch then. */
1711 /*************************************************
1712 * Report the library versions. *
1713 *************************************************/
1715 /* See a description in tls-openssl.c for an explanation of why this exists.
1717 Arguments: a FILE* to print the results to
1722 tls_version_report(FILE *f)
1724 fprintf(f, "Library version: GnuTLS: Compile: %s\n"
1727 gnutls_check_version(NULL));
1730 /* End of tls-gnu.c */