DANE: smtp transport option dane_require_tls_ciphers
[exim.git] / src / src / tls-openssl.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Portions Copyright (c) The OpenSSL Project 1999 */
9
10 /* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
11 library. It is #included into the tls.c file when that library is used. The
12 code herein is based on a patch that was originally contributed by Steve
13 Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
14
15 No cryptographic code is included in Exim. All this module does is to call
16 functions from the OpenSSL library. */
17
18
19 /* Heading stuff */
20
21 #include <openssl/lhash.h>
22 #include <openssl/ssl.h>
23 #include <openssl/err.h>
24 #include <openssl/rand.h>
25 #ifndef OPENSSL_NO_ECDH
26 # include <openssl/ec.h>
27 #endif
28 #ifndef DISABLE_OCSP
29 # include <openssl/ocsp.h>
30 #endif
31 #ifdef SUPPORT_DANE
32 # include "danessl.h"
33 #endif
34
35
36 #ifndef DISABLE_OCSP
37 # define EXIM_OCSP_SKEW_SECONDS (300L)
38 # define EXIM_OCSP_MAX_AGE (-1L)
39 #endif
40
41 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
42 # define EXIM_HAVE_OPENSSL_TLSEXT
43 #endif
44 #if OPENSSL_VERSION_NUMBER >= 0x00908000L
45 # define EXIM_HAVE_RSA_GENKEY_EX
46 #endif
47 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
48 # define EXIM_HAVE_OCSP_RESP_COUNT
49 #else
50 # define EXIM_HAVE_EPHEM_RSA_KEX
51 # define EXIM_HAVE_RAND_PSEUDO
52 #endif
53 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
54 # define EXIM_HAVE_SHA256 /*MMMM*/
55 #endif
56
57 /*
58 * X509_check_host provides sane certificate hostname checking, but was added
59 * to OpenSSL late, after other projects forked off the code-base. So in
60 * addition to guarding against the base version number, beware that LibreSSL
61 * does not (at this time) support this function.
62 *
63 * If LibreSSL gains a different API, perhaps via libtls, then we'll probably
64 * opt to disentangle and ask a LibreSSL user to provide glue for a third
65 * crypto provider for libtls instead of continuing to tie the OpenSSL glue
66 * into even twistier knots. If LibreSSL gains the same API, we can just
67 * change this guard and punt the issue for a while longer.
68 */
69 #ifndef LIBRESSL_VERSION_NUMBER
70 # if OPENSSL_VERSION_NUMBER >= 0x010100000L
71 # define EXIM_HAVE_OPENSSL_CHECKHOST
72 # define EXIM_HAVE_OPENSSL_DH_BITS
73 # endif
74 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
75 && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
76 # define EXIM_HAVE_OPENSSL_CHECKHOST
77 # endif
78 #endif
79
80 #if !defined(LIBRESSL_VERSION_NUMBER) \
81 || LIBRESSL_VERSION_NUMBER >= 0x20010000L
82 # if !defined(OPENSSL_NO_ECDH)
83 # if OPENSSL_VERSION_NUMBER >= 0x0090800fL
84 # define EXIM_HAVE_ECDH /*MMMM*/
85 # endif
86 # if OPENSSL_VERSION_NUMBER >= 0x10002000L
87 # define EXIM_HAVE_OPENSSL_EC_NIST2NID
88 # endif
89 # endif
90 #endif
91
92 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
93 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
94 # define DISABLE_OCSP
95 #endif
96
97 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
98 # include <openssl/x509v3.h>
99 #endif
100
101 /* Structure for collecting random data for seeding. */
102
103 typedef struct randstuff {
104 struct timeval tv;
105 pid_t p;
106 } randstuff;
107
108 /* Local static variables */
109
110 static BOOL client_verify_callback_called = FALSE;
111 static BOOL server_verify_callback_called = FALSE;
112 static const uschar *sid_ctx = US"exim";
113
114 /* We have three different contexts to care about.
115
116 Simple case: client, `client_ctx`
117 As a client, we can be doing a callout or cut-through delivery while receiving
118 a message. So we have a client context, which should have options initialised
119 from the SMTP Transport.
120
121 Server:
122 There are two cases: with and without ServerNameIndication from the client.
123 Given TLS SNI, we can be using different keys, certs and various other
124 configuration settings, because they're re-expanded with $tls_sni set. This
125 allows vhosting with TLS. This SNI is sent in the handshake.
126 A client might not send SNI, so we need a fallback, and an initial setup too.
127 So as a server, we start out using `server_ctx`.
128 If SNI is sent by the client, then we as server, mid-negotiation, try to clone
129 `server_sni` from `server_ctx` and then initialise settings by re-expanding
130 configuration.
131 */
132
133 static SSL_CTX *client_ctx = NULL;
134 static SSL_CTX *server_ctx = NULL;
135 static SSL *client_ssl = NULL;
136 static SSL *server_ssl = NULL;
137
138 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
139 static SSL_CTX *server_sni = NULL;
140 #endif
141
142 static char ssl_errstring[256];
143
144 static int ssl_session_timeout = 200;
145 static BOOL client_verify_optional = FALSE;
146 static BOOL server_verify_optional = FALSE;
147
148 static BOOL reexpand_tls_files_for_sni = FALSE;
149
150
151 typedef struct tls_ext_ctx_cb {
152 uschar *certificate;
153 uschar *privatekey;
154 BOOL is_server;
155 #ifndef DISABLE_OCSP
156 STACK_OF(X509) *verify_stack; /* chain for verifying the proof */
157 union {
158 struct {
159 uschar *file;
160 uschar *file_expanded;
161 OCSP_RESPONSE *response;
162 } server;
163 struct {
164 X509_STORE *verify_store; /* non-null if status requested */
165 BOOL verify_required;
166 } client;
167 } u_ocsp;
168 #endif
169 uschar *dhparam;
170 /* these are cached from first expand */
171 uschar *server_cipher_list;
172 /* only passed down to tls_error: */
173 host_item *host;
174 const uschar * verify_cert_hostnames;
175 #ifndef DISABLE_EVENT
176 uschar * event_action;
177 #endif
178 } tls_ext_ctx_cb;
179
180 /* should figure out a cleanup of API to handle state preserved per
181 implementation, for various reasons, which can be void * in the APIs.
182 For now, we hack around it. */
183 tls_ext_ctx_cb *client_static_cbinfo = NULL;
184 tls_ext_ctx_cb *server_static_cbinfo = NULL;
185
186 static int
187 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
188 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr );
189
190 /* Callbacks */
191 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
192 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
193 #endif
194 #ifndef DISABLE_OCSP
195 static int tls_server_stapling_cb(SSL *s, void *arg);
196 #endif
197
198
199 /*************************************************
200 * Handle TLS error *
201 *************************************************/
202
203 /* Called from lots of places when errors occur before actually starting to do
204 the TLS handshake, that is, while the session is still in clear. Always returns
205 DEFER for a server and FAIL for a client so that most calls can use "return
206 tls_error(...)" to do this processing and then give an appropriate return. A
207 single function is used for both server and client, because it is called from
208 some shared functions.
209
210 Argument:
211 prefix text to include in the logged error
212 host NULL if setting up a server;
213 the connected host if setting up a client
214 msg error message or NULL if we should ask OpenSSL
215 errstr pointer to output error message
216
217 Returns: OK/DEFER/FAIL
218 */
219
220 static int
221 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
222 {
223 if (!msg)
224 {
225 ERR_error_string(ERR_get_error(), ssl_errstring);
226 msg = US ssl_errstring;
227 }
228
229 if (errstr) *errstr = string_sprintf("(%s): %s", prefix, msg);
230 return host ? FAIL : DEFER;
231 }
232
233
234
235 /*************************************************
236 * Callback to generate RSA key *
237 *************************************************/
238
239 /*
240 Arguments:
241 s SSL connection (not used)
242 export not used
243 keylength keylength
244
245 Returns: pointer to generated key
246 */
247
248 static RSA *
249 rsa_callback(SSL *s, int export, int keylength)
250 {
251 RSA *rsa_key;
252 #ifdef EXIM_HAVE_RSA_GENKEY_EX
253 BIGNUM *bn = BN_new();
254 #endif
255
256 export = export; /* Shut picky compilers up */
257 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
258
259 #ifdef EXIM_HAVE_RSA_GENKEY_EX
260 if ( !BN_set_word(bn, (unsigned long)RSA_F4)
261 || !(rsa_key = RSA_new())
262 || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
263 )
264 #else
265 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
266 #endif
267
268 {
269 ERR_error_string(ERR_get_error(), ssl_errstring);
270 log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
271 ssl_errstring);
272 return NULL;
273 }
274 return rsa_key;
275 }
276
277
278
279 /* Extreme debug
280 #ifndef DISABLE_OCSP
281 void
282 x509_store_dump_cert_s_names(X509_STORE * store)
283 {
284 STACK_OF(X509_OBJECT) * roots= store->objs;
285 int i;
286 static uschar name[256];
287
288 for(i= 0; i<sk_X509_OBJECT_num(roots); i++)
289 {
290 X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
291 if(tmp_obj->type == X509_LU_X509)
292 {
293 X509 * current_cert= tmp_obj->data.x509;
294 X509_NAME_oneline(X509_get_subject_name(current_cert), CS name, sizeof(name));
295 name[sizeof(name)-1] = '\0';
296 debug_printf(" %s\n", name);
297 }
298 }
299 }
300 #endif
301 */
302
303
304 #ifndef DISABLE_EVENT
305 static int
306 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
307 BOOL *calledp, const BOOL *optionalp, const uschar * what)
308 {
309 uschar * ev;
310 uschar * yield;
311 X509 * old_cert;
312
313 ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
314 if (ev)
315 {
316 DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
317 old_cert = tlsp->peercert;
318 tlsp->peercert = X509_dup(cert);
319 /* NB we do not bother setting peerdn */
320 if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
321 {
322 log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
323 "depth=%d cert=%s: %s",
324 tlsp == &tls_out ? deliver_host_address : sender_host_address,
325 what, depth, dn, yield);
326 *calledp = TRUE;
327 if (!*optionalp)
328 {
329 if (old_cert) tlsp->peercert = old_cert; /* restore 1st failing cert */
330 return 1; /* reject (leaving peercert set) */
331 }
332 DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
333 "(host in tls_try_verify_hosts)\n");
334 }
335 X509_free(tlsp->peercert);
336 tlsp->peercert = old_cert;
337 }
338 return 0;
339 }
340 #endif
341
342 /*************************************************
343 * Callback for verification *
344 *************************************************/
345
346 /* The SSL library does certificate verification if set up to do so. This
347 callback has the current yes/no state is in "state". If verification succeeded,
348 we set the certificate-verified flag. If verification failed, what happens
349 depends on whether the client is required to present a verifiable certificate
350 or not.
351
352 If verification is optional, we change the state to yes, but still log the
353 verification error. For some reason (it really would help to have proper
354 documentation of OpenSSL), this callback function then gets called again, this
355 time with state = 1. We must take care not to set the private verified flag on
356 the second time through.
357
358 Note: this function is not called if the client fails to present a certificate
359 when asked. We get here only if a certificate has been received. Handling of
360 optional verification for this case is done when requesting SSL to verify, by
361 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
362
363 May be called multiple times for different issues with a certificate, even
364 for a given "depth" in the certificate chain.
365
366 Arguments:
367 preverify_ok current yes/no state as 1/0
368 x509ctx certificate information.
369 tlsp per-direction (client vs. server) support data
370 calledp has-been-called flag
371 optionalp verification-is-optional flag
372
373 Returns: 0 if verification should fail, otherwise 1
374 */
375
376 static int
377 verify_callback(int preverify_ok, X509_STORE_CTX *x509ctx,
378 tls_support *tlsp, BOOL *calledp, BOOL *optionalp)
379 {
380 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
381 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
382 uschar dn[256];
383
384 X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn));
385 dn[sizeof(dn)-1] = '\0';
386
387 if (preverify_ok == 0)
388 {
389 uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
390 *verify_mode, sender_host_address)
391 : US"";
392 log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
393 tlsp == &tls_out ? deliver_host_address : sender_host_address,
394 extra, depth,
395 X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
396 *calledp = TRUE;
397 if (!*optionalp)
398 {
399 if (!tlsp->peercert)
400 tlsp->peercert = X509_dup(cert); /* record failing cert */
401 return 0; /* reject */
402 }
403 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
404 "tls_try_verify_hosts)\n");
405 }
406
407 else if (depth != 0)
408 {
409 DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
410 #ifndef DISABLE_OCSP
411 if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
412 { /* client, wanting stapling */
413 /* Add the server cert's signing chain as the one
414 for the verification of the OCSP stapled information. */
415
416 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
417 cert))
418 ERR_clear_error();
419 sk_X509_push(client_static_cbinfo->verify_stack, cert);
420 }
421 #endif
422 #ifndef DISABLE_EVENT
423 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
424 return 0; /* reject, with peercert set */
425 #endif
426 }
427 else
428 {
429 const uschar * verify_cert_hostnames;
430
431 if ( tlsp == &tls_out
432 && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
433 /* client, wanting hostname check */
434 {
435
436 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
437 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
438 # define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
439 # endif
440 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
441 # define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
442 # endif
443 int sep = 0;
444 const uschar * list = verify_cert_hostnames;
445 uschar * name;
446 int rc;
447 while ((name = string_nextinlist(&list, &sep, NULL, 0)))
448 if ((rc = X509_check_host(cert, CCS name, 0,
449 X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
450 | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
451 NULL)))
452 {
453 if (rc < 0)
454 {
455 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
456 tlsp == &tls_out ? deliver_host_address : sender_host_address);
457 name = NULL;
458 }
459 break;
460 }
461 if (!name)
462 #else
463 if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
464 #endif
465 {
466 uschar * extra = verify_mode
467 ? string_sprintf(" (during %c-verify for [%s])",
468 *verify_mode, sender_host_address)
469 : US"";
470 log_write(0, LOG_MAIN,
471 "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
472 tlsp == &tls_out ? deliver_host_address : sender_host_address,
473 extra, dn, verify_cert_hostnames);
474 *calledp = TRUE;
475 if (!*optionalp)
476 {
477 if (!tlsp->peercert)
478 tlsp->peercert = X509_dup(cert); /* record failing cert */
479 return 0; /* reject */
480 }
481 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
482 "tls_try_verify_hosts)\n");
483 }
484 }
485
486 #ifndef DISABLE_EVENT
487 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
488 return 0; /* reject, with peercert set */
489 #endif
490
491 DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
492 *calledp ? "" : " authenticated", dn);
493 if (!*calledp) tlsp->certificate_verified = TRUE;
494 *calledp = TRUE;
495 }
496
497 return 1; /* accept, at least for this level */
498 }
499
500 static int
501 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
502 {
503 return verify_callback(preverify_ok, x509ctx, &tls_out,
504 &client_verify_callback_called, &client_verify_optional);
505 }
506
507 static int
508 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
509 {
510 return verify_callback(preverify_ok, x509ctx, &tls_in,
511 &server_verify_callback_called, &server_verify_optional);
512 }
513
514
515 #ifdef SUPPORT_DANE
516
517 /* This gets called *by* the dane library verify callback, which interposes
518 itself.
519 */
520 static int
521 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
522 {
523 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
524 uschar dn[256];
525 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
526 #ifndef DISABLE_EVENT
527 BOOL dummy_called, optional = FALSE;
528 #endif
529
530 X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn));
531 dn[sizeof(dn)-1] = '\0';
532
533 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
534 preverify_ok ? "ok":"BAD", depth, dn);
535
536 #ifndef DISABLE_EVENT
537 if (verify_event(&tls_out, cert, depth, dn,
538 &dummy_called, &optional, US"DANE"))
539 return 0; /* reject, with peercert set */
540 #endif
541
542 if (preverify_ok == 1)
543 {
544 tls_out.dane_verified = tls_out.certificate_verified = TRUE;
545 #ifndef DISABLE_OCSP
546 if (client_static_cbinfo->u_ocsp.client.verify_store)
547 { /* client, wanting stapling */
548 /* Add the server cert's signing chain as the one
549 for the verification of the OCSP stapled information. */
550
551 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
552 cert))
553 ERR_clear_error();
554 sk_X509_push(client_static_cbinfo->verify_stack, cert);
555 }
556 #endif
557 }
558 else
559 {
560 int err = X509_STORE_CTX_get_error(x509ctx);
561 DEBUG(D_tls)
562 debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
563 if (err == X509_V_ERR_APPLICATION_VERIFICATION)
564 preverify_ok = 1;
565 }
566 return preverify_ok;
567 }
568
569 #endif /*SUPPORT_DANE*/
570
571
572 /*************************************************
573 * Information callback *
574 *************************************************/
575
576 /* The SSL library functions call this from time to time to indicate what they
577 are doing. We copy the string to the debugging output when TLS debugging has
578 been requested.
579
580 Arguments:
581 s the SSL connection
582 where
583 ret
584
585 Returns: nothing
586 */
587
588 static void
589 info_callback(SSL *s, int where, int ret)
590 {
591 where = where;
592 ret = ret;
593 DEBUG(D_tls) debug_printf("SSL info: %s\n", SSL_state_string_long(s));
594 }
595
596
597
598 /*************************************************
599 * Initialize for DH *
600 *************************************************/
601
602 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
603
604 Arguments:
605 sctx The current SSL CTX (inbound or outbound)
606 dhparam DH parameter file or fixed parameter identity string
607 host connected host, if client; NULL if server
608 errstr error string pointer
609
610 Returns: TRUE if OK (nothing to set up, or setup worked)
611 */
612
613 static BOOL
614 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
615 {
616 BIO *bio;
617 DH *dh;
618 uschar *dhexpanded;
619 const char *pem;
620 int dh_bitsize;
621
622 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
623 return FALSE;
624
625 if (!dhexpanded || !*dhexpanded)
626 bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
627 else if (dhexpanded[0] == '/')
628 {
629 if (!(bio = BIO_new_file(CS dhexpanded, "r")))
630 {
631 tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
632 host, US strerror(errno), errstr);
633 return FALSE;
634 }
635 }
636 else
637 {
638 if (Ustrcmp(dhexpanded, "none") == 0)
639 {
640 DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
641 return TRUE;
642 }
643
644 if (!(pem = std_dh_prime_named(dhexpanded)))
645 {
646 tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
647 host, US strerror(errno), errstr);
648 return FALSE;
649 }
650 bio = BIO_new_mem_buf(CS pem, -1);
651 }
652
653 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
654 {
655 BIO_free(bio);
656 tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
657 host, NULL, errstr);
658 return FALSE;
659 }
660
661 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
662 * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
663 * 2236. But older OpenSSL can only report in bytes (octets), not bits.
664 * If someone wants to dance at the edge, then they can raise the limit or use
665 * current libraries. */
666 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
667 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
668 * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
669 dh_bitsize = DH_bits(dh);
670 #else
671 dh_bitsize = 8 * DH_size(dh);
672 #endif
673
674 /* Even if it is larger, we silently return success rather than cause things
675 * to fail out, so that a too-large DH will not knock out all TLS; it's a
676 * debatable choice. */
677 if (dh_bitsize > tls_dh_max_bits)
678 {
679 DEBUG(D_tls)
680 debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
681 dh_bitsize, tls_dh_max_bits);
682 }
683 else
684 {
685 SSL_CTX_set_tmp_dh(sctx, dh);
686 DEBUG(D_tls)
687 debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
688 dhexpanded ? dhexpanded : US"default", dh_bitsize);
689 }
690
691 DH_free(dh);
692 BIO_free(bio);
693
694 return TRUE;
695 }
696
697
698
699
700 /*************************************************
701 * Initialize for ECDH *
702 *************************************************/
703
704 /* Load parameters for ECDH encryption.
705
706 For now, we stick to NIST P-256 because: it's simple and easy to configure;
707 it avoids any patent issues that might bite redistributors; despite events in
708 the news and concerns over curve choices, we're not cryptographers, we're not
709 pretending to be, and this is "good enough" to be better than no support,
710 protecting against most adversaries. Given another year or two, there might
711 be sufficient clarity about a "right" way forward to let us make an informed
712 decision, instead of a knee-jerk reaction.
713
714 Longer-term, we should look at supporting both various named curves and
715 external files generated with "openssl ecparam", much as we do for init_dh().
716 We should also support "none" as a value, to explicitly avoid initialisation.
717
718 Patches welcome.
719
720 Arguments:
721 sctx The current SSL CTX (inbound or outbound)
722 host connected host, if client; NULL if server
723 errstr error string pointer
724
725 Returns: TRUE if OK (nothing to set up, or setup worked)
726 */
727
728 static BOOL
729 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
730 {
731 #ifdef OPENSSL_NO_ECDH
732 return TRUE;
733 #else
734
735 EC_KEY * ecdh;
736 uschar * exp_curve;
737 int nid;
738 BOOL rv;
739
740 if (host) /* No ECDH setup for clients, only for servers */
741 return TRUE;
742
743 # ifndef EXIM_HAVE_ECDH
744 DEBUG(D_tls)
745 debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
746 return TRUE;
747 # else
748
749 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
750 return FALSE;
751 if (!exp_curve || !*exp_curve)
752 return TRUE;
753
754 /* "auto" needs to be handled carefully.
755 * OpenSSL < 1.0.2: we do not select anything, but fallback to prime256v1
756 * OpenSSL < 1.1.0: we have to call SSL_CTX_set_ecdh_auto
757 * (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
758 * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
759 * https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
760 */
761 if (Ustrcmp(exp_curve, "auto") == 0)
762 {
763 #if OPENSSL_VERSION_NUMBER < 0x10002000L
764 DEBUG(D_tls) debug_printf(
765 "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
766 exp_curve = US"prime256v1";
767 #else
768 # if defined SSL_CTRL_SET_ECDH_AUTO
769 DEBUG(D_tls) debug_printf(
770 "ECDH OpenSSL 1.0.2+ temp key parameter settings: autoselection\n");
771 SSL_CTX_set_ecdh_auto(sctx, 1);
772 return TRUE;
773 # else
774 DEBUG(D_tls) debug_printf(
775 "ECDH OpenSSL 1.1.0+ temp key parameter settings: default selection\n");
776 return TRUE;
777 # endif
778 #endif
779 }
780
781 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
782 if ( (nid = OBJ_sn2nid (CCS exp_curve)) == NID_undef
783 # ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
784 && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
785 # endif
786 )
787 {
788 tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
789 host, NULL, errstr);
790 return FALSE;
791 }
792
793 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
794 {
795 tls_error(US"Unable to create ec curve", host, NULL, errstr);
796 return FALSE;
797 }
798
799 /* The "tmp" in the name here refers to setting a temporary key
800 not to the stability of the interface. */
801
802 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
803 tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
804 else
805 DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
806
807 EC_KEY_free(ecdh);
808 return !rv;
809
810 # endif /*EXIM_HAVE_ECDH*/
811 #endif /*OPENSSL_NO_ECDH*/
812 }
813
814
815
816
817 #ifndef DISABLE_OCSP
818 /*************************************************
819 * Load OCSP information into state *
820 *************************************************/
821 /* Called to load the server OCSP response from the given file into memory, once
822 caller has determined this is needed. Checks validity. Debugs a message
823 if invalid.
824
825 ASSUMES: single response, for single cert.
826
827 Arguments:
828 sctx the SSL_CTX* to update
829 cbinfo various parts of session state
830 expanded the filename putatively holding an OCSP response
831
832 */
833
834 static void
835 ocsp_load_response(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo, const uschar *expanded)
836 {
837 BIO * bio;
838 OCSP_RESPONSE * resp;
839 OCSP_BASICRESP * basic_response;
840 OCSP_SINGLERESP * single_response;
841 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
842 STACK_OF(X509) * sk;
843 unsigned long verify_flags;
844 int status, reason, i;
845
846 cbinfo->u_ocsp.server.file_expanded = string_copy(expanded);
847 if (cbinfo->u_ocsp.server.response)
848 {
849 OCSP_RESPONSE_free(cbinfo->u_ocsp.server.response);
850 cbinfo->u_ocsp.server.response = NULL;
851 }
852
853 if (!(bio = BIO_new_file(CS cbinfo->u_ocsp.server.file_expanded, "rb")))
854 {
855 DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
856 cbinfo->u_ocsp.server.file_expanded);
857 return;
858 }
859
860 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
861 BIO_free(bio);
862 if (!resp)
863 {
864 DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
865 return;
866 }
867
868 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
869 {
870 DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
871 OCSP_response_status_str(status), status);
872 goto bad;
873 }
874
875 if (!(basic_response = OCSP_response_get1_basic(resp)))
876 {
877 DEBUG(D_tls)
878 debug_printf("OCSP response parse error: unable to extract basic response.\n");
879 goto bad;
880 }
881
882 sk = cbinfo->verify_stack;
883 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
884
885 /* May need to expose ability to adjust those flags?
886 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
887 OCSP_TRUSTOTHER OCSP_NOINTERN */
888
889 /* This does a full verify on the OCSP proof before we load it for serving
890 up; possibly overkill - just date-checks might be nice enough.
891
892 OCSP_basic_verify takes a "store" arg, but does not
893 use it for the chain verification, which is all we do
894 when OCSP_NOVERIFY is set. The content from the wire
895 "basic_response" and a cert-stack "sk" are all that is used.
896
897 We have a stack, loaded in setup_certs() if tls_verify_certificates
898 was a file (not a directory, or "system"). It is unfortunate we
899 cannot used the connection context store, as that would neatly
900 handle the "system" case too, but there seems to be no library
901 function for getting a stack from a store.
902 [ In OpenSSL 1.1 - ? X509_STORE_CTX_get0_chain(ctx) ? ]
903 We do not free the stack since it could be needed a second time for
904 SNI handling.
905
906 Separately we might try to replace using OCSP_basic_verify() - which seems to not
907 be a public interface into the OpenSSL library (there's no manual entry) -
908 But what with? We also use OCSP_basic_verify in the client stapling callback.
909 And there we NEED it; we must verify that status... unless the
910 library does it for us anyway? */
911
912 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
913 {
914 DEBUG(D_tls)
915 {
916 ERR_error_string(ERR_get_error(), ssl_errstring);
917 debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
918 }
919 goto bad;
920 }
921
922 /* Here's the simplifying assumption: there's only one response, for the
923 one certificate we use, and nothing for anything else in a chain. If this
924 proves false, we need to extract a cert id from our issued cert
925 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
926 right cert in the stack and then calls OCSP_single_get0_status()).
927
928 I'm hoping to avoid reworking a bunch more of how we handle state here. */
929
930 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
931 {
932 DEBUG(D_tls)
933 debug_printf("Unable to get first response from OCSP basic response.\n");
934 goto bad;
935 }
936
937 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
938 if (status != V_OCSP_CERTSTATUS_GOOD)
939 {
940 DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
941 OCSP_cert_status_str(status), status,
942 OCSP_crl_reason_str(reason), reason);
943 goto bad;
944 }
945
946 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
947 {
948 DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
949 goto bad;
950 }
951
952 supply_response:
953 cbinfo->u_ocsp.server.response = resp; /*XXX stack?*/
954 return;
955
956 bad:
957 if (running_in_test_harness)
958 {
959 extern char ** environ;
960 uschar ** p;
961 if (environ) for (p = USS environ; *p; p++)
962 if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
963 {
964 DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
965 goto supply_response;
966 }
967 }
968 return;
969 }
970 #endif /*!DISABLE_OCSP*/
971
972
973
974
975 /* Create and install a selfsigned certificate, for use in server mode */
976
977 static int
978 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
979 {
980 X509 * x509 = NULL;
981 EVP_PKEY * pkey;
982 RSA * rsa;
983 X509_NAME * name;
984 uschar * where;
985
986 where = US"allocating pkey";
987 if (!(pkey = EVP_PKEY_new()))
988 goto err;
989
990 where = US"allocating cert";
991 if (!(x509 = X509_new()))
992 goto err;
993
994 where = US"generating pkey";
995 if (!(rsa = rsa_callback(NULL, 0, 1024)))
996 goto err;
997
998 where = US"assigning pkey";
999 if (!EVP_PKEY_assign_RSA(pkey, rsa))
1000 goto err;
1001
1002 X509_set_version(x509, 2); /* N+1 - version 3 */
1003 ASN1_INTEGER_set(X509_get_serialNumber(x509), 0);
1004 X509_gmtime_adj(X509_get_notBefore(x509), 0);
1005 X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60); /* 1 hour */
1006 X509_set_pubkey(x509, pkey);
1007
1008 name = X509_get_subject_name(x509);
1009 X509_NAME_add_entry_by_txt(name, "C",
1010 MBSTRING_ASC, CUS "UK", -1, -1, 0);
1011 X509_NAME_add_entry_by_txt(name, "O",
1012 MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
1013 X509_NAME_add_entry_by_txt(name, "CN",
1014 MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
1015 X509_set_issuer_name(x509, name);
1016
1017 where = US"signing cert";
1018 if (!X509_sign(x509, pkey, EVP_md5()))
1019 goto err;
1020
1021 where = US"installing selfsign cert";
1022 if (!SSL_CTX_use_certificate(sctx, x509))
1023 goto err;
1024
1025 where = US"installing selfsign key";
1026 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
1027 goto err;
1028
1029 return OK;
1030
1031 err:
1032 (void) tls_error(where, NULL, NULL, errstr);
1033 if (x509) X509_free(x509);
1034 if (pkey) EVP_PKEY_free(pkey);
1035 return DEFER;
1036 }
1037
1038
1039
1040
1041 static int
1042 tls_add_certfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1043 uschar ** errstr)
1044 {
1045 DEBUG(D_tls) debug_printf("tls_certificate file %s\n", file);
1046 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1047 return tls_error(string_sprintf(
1048 "SSL_CTX_use_certificate_chain_file file=%s", file),
1049 cbinfo->host, NULL, errstr);
1050 return 0;
1051 }
1052
1053 static int
1054 tls_add_pkeyfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1055 uschar ** errstr)
1056 {
1057 DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", file);
1058 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1059 return tls_error(string_sprintf(
1060 "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1061 return 0;
1062 }
1063
1064
1065 /*************************************************
1066 * Expand key and cert file specs *
1067 *************************************************/
1068
1069 /* Called once during tls_init and possibly again during TLS setup, for a
1070 new context, if Server Name Indication was used and tls_sni was seen in
1071 the certificate string.
1072
1073 Arguments:
1074 sctx the SSL_CTX* to update
1075 cbinfo various parts of session state
1076 errstr error string pointer
1077
1078 Returns: OK/DEFER/FAIL
1079 */
1080
1081 static int
1082 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo,
1083 uschar ** errstr)
1084 {
1085 uschar *expanded;
1086
1087 if (!cbinfo->certificate)
1088 {
1089 if (!cbinfo->is_server) /* client */
1090 return OK;
1091 /* server */
1092 if (tls_install_selfsign(sctx, errstr) != OK)
1093 return DEFER;
1094 }
1095 else
1096 {
1097 int err;
1098
1099 if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
1100 Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
1101 Ustrstr(cbinfo->certificate, US"tls_out_sni")
1102 )
1103 reexpand_tls_files_for_sni = TRUE;
1104
1105 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded, errstr))
1106 return DEFER;
1107
1108 if (expanded)
1109 if (cbinfo->is_server)
1110 {
1111 const uschar * file_list = expanded;
1112 int sep = 0;
1113 uschar * file;
1114
1115 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1116 if ((err = tls_add_certfile(sctx, cbinfo, file, errstr)))
1117 return err;
1118 }
1119 else /* would there ever be a need for multiple client certs? */
1120 if ((err = tls_add_certfile(sctx, cbinfo, expanded, errstr)))
1121 return err;
1122
1123 if (cbinfo->privatekey != NULL &&
1124 !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded, errstr))
1125 return DEFER;
1126
1127 /* If expansion was forced to fail, key_expanded will be NULL. If the result
1128 of the expansion is an empty string, ignore it also, and assume the private
1129 key is in the same file as the certificate. */
1130
1131 if (expanded && *expanded)
1132 if (cbinfo->is_server)
1133 {
1134 const uschar * file_list = expanded;
1135 int sep = 0;
1136 uschar * file;
1137
1138 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1139 if ((err = tls_add_pkeyfile(sctx, cbinfo, file, errstr)))
1140 return err;
1141 }
1142 else /* would there ever be a need for multiple client certs? */
1143 if ((err = tls_add_pkeyfile(sctx, cbinfo, expanded, errstr)))
1144 return err;
1145 }
1146
1147 #ifndef DISABLE_OCSP
1148 if (cbinfo->is_server && cbinfo->u_ocsp.server.file)
1149 {
1150 /*XXX stack*/
1151 if (!expand_check(cbinfo->u_ocsp.server.file, US"tls_ocsp_file", &expanded, errstr))
1152 return DEFER;
1153
1154 if (expanded && *expanded)
1155 {
1156 DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
1157 if ( cbinfo->u_ocsp.server.file_expanded
1158 && (Ustrcmp(expanded, cbinfo->u_ocsp.server.file_expanded) == 0))
1159 {
1160 DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1161 }
1162 else
1163 ocsp_load_response(sctx, cbinfo, expanded);
1164 }
1165 }
1166 #endif
1167
1168 return OK;
1169 }
1170
1171
1172
1173
1174 /*************************************************
1175 * Callback to handle SNI *
1176 *************************************************/
1177
1178 /* Called when acting as server during the TLS session setup if a Server Name
1179 Indication extension was sent by the client.
1180
1181 API documentation is OpenSSL s_server.c implementation.
1182
1183 Arguments:
1184 s SSL* of the current session
1185 ad unknown (part of OpenSSL API) (unused)
1186 arg Callback of "our" registered data
1187
1188 Returns: SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
1189 */
1190
1191 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1192 static int
1193 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
1194 {
1195 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
1196 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1197 int rc;
1198 int old_pool = store_pool;
1199 uschar * dummy_errstr;
1200
1201 if (!servername)
1202 return SSL_TLSEXT_ERR_OK;
1203
1204 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
1205 reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
1206
1207 /* Make the extension value available for expansion */
1208 store_pool = POOL_PERM;
1209 tls_in.sni = string_copy(US servername);
1210 store_pool = old_pool;
1211
1212 if (!reexpand_tls_files_for_sni)
1213 return SSL_TLSEXT_ERR_OK;
1214
1215 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
1216 not confident that memcpy wouldn't break some internal reference counting.
1217 Especially since there's a references struct member, which would be off. */
1218
1219 if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
1220 {
1221 ERR_error_string(ERR_get_error(), ssl_errstring);
1222 DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
1223 return SSL_TLSEXT_ERR_NOACK;
1224 }
1225
1226 /* Not sure how many of these are actually needed, since SSL object
1227 already exists. Might even need this selfsame callback, for reneg? */
1228
1229 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
1230 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
1231 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
1232 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
1233 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
1234 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
1235
1236 if ( !init_dh(server_sni, cbinfo->dhparam, NULL, &dummy_errstr)
1237 || !init_ecdh(server_sni, NULL, &dummy_errstr)
1238 )
1239 return SSL_TLSEXT_ERR_NOACK;
1240
1241 if (cbinfo->server_cipher_list)
1242 SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list);
1243 #ifndef DISABLE_OCSP
1244 if (cbinfo->u_ocsp.server.file)
1245 {
1246 SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
1247 SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
1248 }
1249 #endif
1250
1251 if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
1252 verify_callback_server, &dummy_errstr)) != OK)
1253 return SSL_TLSEXT_ERR_NOACK;
1254
1255 /* do this after setup_certs, because this can require the certs for verifying
1256 OCSP information. */
1257 if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
1258 return SSL_TLSEXT_ERR_NOACK;
1259
1260 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
1261 SSL_set_SSL_CTX(s, server_sni);
1262
1263 return SSL_TLSEXT_ERR_OK;
1264 }
1265 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
1266
1267
1268
1269
1270 #ifndef DISABLE_OCSP
1271
1272 /*************************************************
1273 * Callback to handle OCSP Stapling *
1274 *************************************************/
1275
1276 /* Called when acting as server during the TLS session setup if the client
1277 requests OCSP information with a Certificate Status Request.
1278
1279 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1280 project.
1281
1282 */
1283
1284 static int
1285 tls_server_stapling_cb(SSL *s, void *arg)
1286 {
1287 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1288 uschar *response_der; /*XXX blob */
1289 int response_der_len;
1290
1291 /*XXX stack: use SSL_get_certificate() to see which cert; from that work
1292 out which ocsp blob to send. Unfortunately, SSL_get_certificate is known
1293 buggy in current OpenSSL; it returns the last cert loaded always rather than
1294 the one actually presented. So we can't support a stack of OCSP proofs at
1295 this time. */
1296
1297 DEBUG(D_tls)
1298 debug_printf("Received TLS status request (OCSP stapling); %s response\n",
1299 cbinfo->u_ocsp.server.response ? "have" : "lack");
1300
1301 tls_in.ocsp = OCSP_NOT_RESP;
1302 if (!cbinfo->u_ocsp.server.response)
1303 return SSL_TLSEXT_ERR_NOACK;
1304
1305 response_der = NULL;
1306 response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response, /*XXX stack*/
1307 &response_der);
1308 if (response_der_len <= 0)
1309 return SSL_TLSEXT_ERR_NOACK;
1310
1311 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
1312 tls_in.ocsp = OCSP_VFIED;
1313 return SSL_TLSEXT_ERR_OK;
1314 }
1315
1316
1317 static void
1318 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1319 {
1320 BIO_printf(bp, "\t%s: ", str);
1321 ASN1_GENERALIZEDTIME_print(bp, time);
1322 BIO_puts(bp, "\n");
1323 }
1324
1325 static int
1326 tls_client_stapling_cb(SSL *s, void *arg)
1327 {
1328 tls_ext_ctx_cb * cbinfo = arg;
1329 const unsigned char * p;
1330 int len;
1331 OCSP_RESPONSE * rsp;
1332 OCSP_BASICRESP * bs;
1333 int i;
1334
1335 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1336 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1337 if(!p)
1338 {
1339 /* Expect this when we requested ocsp but got none */
1340 if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
1341 log_write(0, LOG_MAIN, "Received TLS status callback, null content");
1342 else
1343 DEBUG(D_tls) debug_printf(" null\n");
1344 return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1345 }
1346
1347 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1348 {
1349 tls_out.ocsp = OCSP_FAILED;
1350 if (LOGGING(tls_cipher))
1351 log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
1352 else
1353 DEBUG(D_tls) debug_printf(" parse error\n");
1354 return 0;
1355 }
1356
1357 if(!(bs = OCSP_response_get1_basic(rsp)))
1358 {
1359 tls_out.ocsp = OCSP_FAILED;
1360 if (LOGGING(tls_cipher))
1361 log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1362 else
1363 DEBUG(D_tls) debug_printf(" error parsing response\n");
1364 OCSP_RESPONSE_free(rsp);
1365 return 0;
1366 }
1367
1368 /* We'd check the nonce here if we'd put one in the request. */
1369 /* However that would defeat cacheability on the server so we don't. */
1370
1371 /* This section of code reworked from OpenSSL apps source;
1372 The OpenSSL Project retains copyright:
1373 Copyright (c) 1999 The OpenSSL Project. All rights reserved.
1374 */
1375 {
1376 BIO * bp = NULL;
1377 int status, reason;
1378 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1379
1380 DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1381
1382 /*OCSP_RESPONSE_print(bp, rsp, 0); extreme debug: stapling content */
1383
1384 /* Use the chain that verified the server cert to verify the stapled info */
1385 /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1386
1387 if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
1388 cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1389 {
1390 tls_out.ocsp = OCSP_FAILED;
1391 if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1392 "Received TLS cert status response, itself unverifiable: %s",
1393 ERR_reason_error_string(ERR_peek_error()));
1394 BIO_printf(bp, "OCSP response verify failure\n");
1395 ERR_print_errors(bp);
1396 OCSP_RESPONSE_print(bp, rsp, 0);
1397 goto failed;
1398 }
1399
1400 BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1401
1402 /*XXX So we have a good stapled OCSP status. How do we know
1403 it is for the cert of interest? OpenSSL 1.1.0 has a routine
1404 OCSP_resp_find_status() which matches on a cert id, which presumably
1405 we should use. Making an id needs OCSP_cert_id_new(), which takes
1406 issuerName, issuerKey, serialNumber. Are they all in the cert?
1407
1408 For now, carry on blindly accepting the resp. */
1409
1410 {
1411 OCSP_SINGLERESP * single;
1412
1413 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
1414 if (OCSP_resp_count(bs) != 1)
1415 #else
1416 STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1417 if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1418 #endif
1419 {
1420 tls_out.ocsp = OCSP_FAILED;
1421 log_write(0, LOG_MAIN, "OCSP stapling "
1422 "with multiple responses not handled");
1423 goto failed;
1424 }
1425 single = OCSP_resp_get0(bs, 0);
1426 status = OCSP_single_get0_status(single, &reason, &rev,
1427 &thisupd, &nextupd);
1428 }
1429
1430 DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1431 DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1432 if (!OCSP_check_validity(thisupd, nextupd,
1433 EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1434 {
1435 tls_out.ocsp = OCSP_FAILED;
1436 DEBUG(D_tls) ERR_print_errors(bp);
1437 log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1438 }
1439 else
1440 {
1441 DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1442 OCSP_cert_status_str(status));
1443 switch(status)
1444 {
1445 case V_OCSP_CERTSTATUS_GOOD:
1446 tls_out.ocsp = OCSP_VFIED;
1447 i = 1;
1448 goto good;
1449 case V_OCSP_CERTSTATUS_REVOKED:
1450 tls_out.ocsp = OCSP_FAILED;
1451 log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1452 reason != -1 ? "; reason: " : "",
1453 reason != -1 ? OCSP_crl_reason_str(reason) : "");
1454 DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1455 break;
1456 default:
1457 tls_out.ocsp = OCSP_FAILED;
1458 log_write(0, LOG_MAIN,
1459 "Server certificate status unknown, in OCSP stapling");
1460 break;
1461 }
1462 }
1463 failed:
1464 i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1465 good:
1466 BIO_free(bp);
1467 }
1468
1469 OCSP_RESPONSE_free(rsp);
1470 return i;
1471 }
1472 #endif /*!DISABLE_OCSP*/
1473
1474
1475 /*************************************************
1476 * Initialize for TLS *
1477 *************************************************/
1478
1479 /* Called from both server and client code, to do preliminary initialization
1480 of the library. We allocate and return a context structure.
1481
1482 Arguments:
1483 ctxp returned SSL context
1484 host connected host, if client; NULL if server
1485 dhparam DH parameter file
1486 certificate certificate file
1487 privatekey private key
1488 ocsp_file file of stapling info (server); flag for require ocsp (client)
1489 addr address if client; NULL if server (for some randomness)
1490 cbp place to put allocated callback context
1491 errstr error string pointer
1492
1493 Returns: OK/DEFER/FAIL
1494 */
1495
1496 static int
1497 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1498 uschar *privatekey,
1499 #ifndef DISABLE_OCSP
1500 uschar *ocsp_file, /*XXX stack, in server*/
1501 #endif
1502 address_item *addr, tls_ext_ctx_cb ** cbp, uschar ** errstr)
1503 {
1504 SSL_CTX * ctx;
1505 long init_options;
1506 int rc;
1507 tls_ext_ctx_cb * cbinfo;
1508
1509 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1510 cbinfo->certificate = certificate;
1511 cbinfo->privatekey = privatekey;
1512 cbinfo->is_server = host==NULL;
1513 #ifndef DISABLE_OCSP
1514 cbinfo->verify_stack = NULL;
1515 if (!host)
1516 {
1517 cbinfo->u_ocsp.server.file = ocsp_file;
1518 cbinfo->u_ocsp.server.file_expanded = NULL;
1519 cbinfo->u_ocsp.server.response = NULL;
1520 }
1521 else
1522 cbinfo->u_ocsp.client.verify_store = NULL;
1523 #endif
1524 cbinfo->dhparam = dhparam;
1525 cbinfo->server_cipher_list = NULL;
1526 cbinfo->host = host;
1527 #ifndef DISABLE_EVENT
1528 cbinfo->event_action = NULL;
1529 #endif
1530
1531 SSL_load_error_strings(); /* basic set up */
1532 OpenSSL_add_ssl_algorithms();
1533
1534 #ifdef EXIM_HAVE_SHA256
1535 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1536 list of available digests. */
1537 EVP_add_digest(EVP_sha256());
1538 #endif
1539
1540 /* Create a context.
1541 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1542 negotiation in the different methods; as far as I can tell, the only
1543 *_{server,client}_method which allows negotiation is SSLv23, which exists even
1544 when OpenSSL is built without SSLv2 support.
1545 By disabling with openssl_options, we can let admins re-enable with the
1546 existing knob. */
1547
1548 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1549 return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1550
1551 /* It turns out that we need to seed the random number generator this early in
1552 order to get the full complement of ciphers to work. It took me roughly a day
1553 of work to discover this by experiment.
1554
1555 On systems that have /dev/urandom, SSL may automatically seed itself from
1556 there. Otherwise, we have to make something up as best we can. Double check
1557 afterwards. */
1558
1559 if (!RAND_status())
1560 {
1561 randstuff r;
1562 gettimeofday(&r.tv, NULL);
1563 r.p = getpid();
1564
1565 RAND_seed(US (&r), sizeof(r));
1566 RAND_seed(US big_buffer, big_buffer_size);
1567 if (addr != NULL) RAND_seed(US addr, sizeof(addr));
1568
1569 if (!RAND_status())
1570 return tls_error(US"RAND_status", host,
1571 US"unable to seed random number generator", errstr);
1572 }
1573
1574 /* Set up the information callback, which outputs if debugging is at a suitable
1575 level. */
1576
1577 DEBUG(D_tls) SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1578
1579 /* Automatically re-try reads/writes after renegotiation. */
1580 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1581
1582 /* Apply administrator-supplied work-arounds.
1583 Historically we applied just one requested option,
1584 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1585 moved to an administrator-controlled list of options to specify and
1586 grandfathered in the first one as the default value for "openssl_options".
1587
1588 No OpenSSL version number checks: the options we accept depend upon the
1589 availability of the option value macros from OpenSSL. */
1590
1591 if (!tls_openssl_options_parse(openssl_options, &init_options))
1592 return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
1593
1594 if (init_options)
1595 {
1596 DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
1597 if (!(SSL_CTX_set_options(ctx, init_options)))
1598 return tls_error(string_sprintf(
1599 "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
1600 }
1601 else
1602 DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
1603
1604 /* Disable session cache unconditionally */
1605
1606 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1607
1608 /* Initialize with DH parameters if supplied */
1609 /* Initialize ECDH temp key parameter selection */
1610
1611 if ( !init_dh(ctx, dhparam, host, errstr)
1612 || !init_ecdh(ctx, host, errstr)
1613 )
1614 return DEFER;
1615
1616 /* Set up certificate and key (and perhaps OCSP info) */
1617
1618 if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
1619 return rc;
1620
1621 /* If we need to handle SNI or OCSP, do so */
1622
1623 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1624 # ifndef DISABLE_OCSP
1625 if (!(cbinfo->verify_stack = sk_X509_new_null()))
1626 {
1627 DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
1628 return FAIL;
1629 }
1630 # endif
1631
1632 if (host == NULL) /* server */
1633 {
1634 # ifndef DISABLE_OCSP
1635 /* We check u_ocsp.server.file, not server.response, because we care about if
1636 the option exists, not what the current expansion might be, as SNI might
1637 change the certificate and OCSP file in use between now and the time the
1638 callback is invoked. */
1639 if (cbinfo->u_ocsp.server.file)
1640 {
1641 SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
1642 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
1643 }
1644 # endif
1645 /* We always do this, so that $tls_sni is available even if not used in
1646 tls_certificate */
1647 SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
1648 SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
1649 }
1650 # ifndef DISABLE_OCSP
1651 else /* client */
1652 if(ocsp_file) /* wanting stapling */
1653 {
1654 if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
1655 {
1656 DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
1657 return FAIL;
1658 }
1659 SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
1660 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
1661 }
1662 # endif
1663 #endif
1664
1665 cbinfo->verify_cert_hostnames = NULL;
1666
1667 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
1668 /* Set up the RSA callback */
1669 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
1670 #endif
1671
1672 /* Finally, set the timeout, and we are done */
1673
1674 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
1675 DEBUG(D_tls) debug_printf("Initialized TLS\n");
1676
1677 *cbp = cbinfo;
1678 *ctxp = ctx;
1679
1680 return OK;
1681 }
1682
1683
1684
1685
1686 /*************************************************
1687 * Get name of cipher in use *
1688 *************************************************/
1689
1690 /*
1691 Argument: pointer to an SSL structure for the connection
1692 buffer to use for answer
1693 size of buffer
1694 pointer to number of bits for cipher
1695 Returns: nothing
1696 */
1697
1698 static void
1699 construct_cipher_name(SSL *ssl, uschar *cipherbuf, int bsize, int *bits)
1700 {
1701 /* With OpenSSL 1.0.0a, this needs to be const but the documentation doesn't
1702 yet reflect that. It should be a safe change anyway, even 0.9.8 versions have
1703 the accessor functions use const in the prototype. */
1704 const SSL_CIPHER *c;
1705 const uschar *ver;
1706
1707 ver = (const uschar *)SSL_get_version(ssl);
1708
1709 c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
1710 SSL_CIPHER_get_bits(c, bits);
1711
1712 string_format(cipherbuf, bsize, "%s:%s:%u", ver,
1713 SSL_CIPHER_get_name(c), *bits);
1714
1715 DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
1716 }
1717
1718
1719 static void
1720 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned bsize)
1721 {
1722 /*XXX we might consider a list-of-certs variable for the cert chain.
1723 SSL_get_peer_cert_chain(SSL*). We'd need a new variable type and support
1724 in list-handling functions, also consider the difference between the entire
1725 chain and the elements sent by the peer. */
1726
1727 /* Will have already noted peercert on a verify fail; possibly not the leaf */
1728 if (!tlsp->peercert)
1729 tlsp->peercert = SSL_get_peer_certificate(ssl);
1730 /* Beware anonymous ciphers which lead to server_cert being NULL */
1731 if (tlsp->peercert)
1732 {
1733 X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, bsize);
1734 peerdn[bsize-1] = '\0';
1735 tlsp->peerdn = peerdn; /*XXX a static buffer... */
1736 }
1737 else
1738 tlsp->peerdn = NULL;
1739 }
1740
1741
1742
1743
1744
1745 /*************************************************
1746 * Set up for verifying certificates *
1747 *************************************************/
1748
1749 /* Load certs from file, return TRUE on success */
1750
1751 static BOOL
1752 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
1753 {
1754 BIO * bp;
1755 X509 * x;
1756
1757 while (sk_X509_num(verify_stack) > 0)
1758 X509_free(sk_X509_pop(verify_stack));
1759
1760 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
1761 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
1762 sk_X509_push(verify_stack, x);
1763 BIO_free(bp);
1764 return TRUE;
1765 }
1766
1767
1768
1769 /* Called by both client and server startup; on the server possibly
1770 repeated after a Server Name Indication.
1771
1772 Arguments:
1773 sctx SSL_CTX* to initialise
1774 certs certs file or NULL
1775 crl CRL file or NULL
1776 host NULL in a server; the remote host in a client
1777 optional TRUE if called from a server for a host in tls_try_verify_hosts;
1778 otherwise passed as FALSE
1779 cert_vfy_cb Callback function for certificate verification
1780 errstr error string pointer
1781
1782 Returns: OK/DEFER/FAIL
1783 */
1784
1785 static int
1786 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
1787 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
1788 {
1789 uschar *expcerts, *expcrl;
1790
1791 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
1792 return DEFER;
1793 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
1794
1795 if (expcerts && *expcerts)
1796 {
1797 /* Tell the library to use its compiled-in location for the system default
1798 CA bundle. Then add the ones specified in the config, if any. */
1799
1800 if (!SSL_CTX_set_default_verify_paths(sctx))
1801 return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
1802
1803 if (Ustrcmp(expcerts, "system") != 0)
1804 {
1805 struct stat statbuf;
1806
1807 if (Ustat(expcerts, &statbuf) < 0)
1808 {
1809 log_write(0, LOG_MAIN|LOG_PANIC,
1810 "failed to stat %s for certificates", expcerts);
1811 return DEFER;
1812 }
1813 else
1814 {
1815 uschar *file, *dir;
1816 if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1817 { file = NULL; dir = expcerts; }
1818 else
1819 {
1820 file = expcerts; dir = NULL;
1821 #ifndef DISABLE_OCSP
1822 /* In the server if we will be offering an OCSP proof, load chain from
1823 file for verifying the OCSP proof at load time. */
1824
1825 if ( !host
1826 && statbuf.st_size > 0
1827 && server_static_cbinfo->u_ocsp.server.file
1828 && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
1829 )
1830 {
1831 log_write(0, LOG_MAIN|LOG_PANIC,
1832 "failed to load cert chain from %s", file);
1833 return DEFER;
1834 }
1835 #endif
1836 }
1837
1838 /* If a certificate file is empty, the next function fails with an
1839 unhelpful error message. If we skip it, we get the correct behaviour (no
1840 certificates are recognized, but the error message is still misleading (it
1841 says no certificate was supplied). But this is better. */
1842
1843 if ( (!file || statbuf.st_size > 0)
1844 && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
1845 return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
1846
1847 /* Load the list of CAs for which we will accept certs, for sending
1848 to the client. This is only for the one-file tls_verify_certificates
1849 variant.
1850 If a list isn't loaded into the server, but
1851 some verify locations are set, the server end appears to make
1852 a wildcard request for client certs.
1853 Meanwhile, the client library as default behaviour *ignores* the list
1854 we send over the wire - see man SSL_CTX_set_client_cert_cb.
1855 Because of this, and that the dir variant is likely only used for
1856 the public-CA bundle (not for a private CA), not worth fixing.
1857 */
1858 if (file)
1859 {
1860 STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
1861
1862 SSL_CTX_set_client_CA_list(sctx, names);
1863 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
1864 sk_X509_NAME_num(names));
1865 }
1866 }
1867 }
1868
1869 /* Handle a certificate revocation list. */
1870
1871 #if OPENSSL_VERSION_NUMBER > 0x00907000L
1872
1873 /* This bit of code is now the version supplied by Lars Mainka. (I have
1874 merely reformatted it into the Exim code style.)
1875
1876 "From here I changed the code to add support for multiple crl's
1877 in pem format in one file or to support hashed directory entries in
1878 pem format instead of a file. This method now uses the library function
1879 X509_STORE_load_locations to add the CRL location to the SSL context.
1880 OpenSSL will then handle the verify against CA certs and CRLs by
1881 itself in the verify callback." */
1882
1883 if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
1884 if (expcrl && *expcrl)
1885 {
1886 struct stat statbufcrl;
1887 if (Ustat(expcrl, &statbufcrl) < 0)
1888 {
1889 log_write(0, LOG_MAIN|LOG_PANIC,
1890 "failed to stat %s for certificates revocation lists", expcrl);
1891 return DEFER;
1892 }
1893 else
1894 {
1895 /* is it a file or directory? */
1896 uschar *file, *dir;
1897 X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
1898 if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
1899 {
1900 file = NULL;
1901 dir = expcrl;
1902 DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
1903 }
1904 else
1905 {
1906 file = expcrl;
1907 dir = NULL;
1908 DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
1909 }
1910 if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
1911 return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
1912
1913 /* setting the flags to check against the complete crl chain */
1914
1915 X509_STORE_set_flags(cvstore,
1916 X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
1917 }
1918 }
1919
1920 #endif /* OPENSSL_VERSION_NUMBER > 0x00907000L */
1921
1922 /* If verification is optional, don't fail if no certificate */
1923
1924 SSL_CTX_set_verify(sctx,
1925 SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
1926 cert_vfy_cb);
1927 }
1928
1929 return OK;
1930 }
1931
1932
1933
1934 /*************************************************
1935 * Start a TLS session in a server *
1936 *************************************************/
1937
1938 /* This is called when Exim is running as a server, after having received
1939 the STARTTLS command. It must respond to that command, and then negotiate
1940 a TLS session.
1941
1942 Arguments:
1943 require_ciphers allowed ciphers
1944 errstr pointer to error message
1945
1946 Returns: OK on success
1947 DEFER for errors before the start of the negotiation
1948 FAIL for errors during the negotiation; the server can't
1949 continue running.
1950 */
1951
1952 int
1953 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
1954 {
1955 int rc;
1956 uschar * expciphers;
1957 tls_ext_ctx_cb * cbinfo;
1958 static uschar peerdn[256];
1959 static uschar cipherbuf[256];
1960
1961 /* Check for previous activation */
1962
1963 if (tls_in.active >= 0)
1964 {
1965 tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
1966 smtp_printf("554 Already in TLS\r\n", FALSE);
1967 return FAIL;
1968 }
1969
1970 /* Initialize the SSL library. If it fails, it will already have logged
1971 the error. */
1972
1973 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
1974 #ifndef DISABLE_OCSP
1975 tls_ocsp_file, /*XXX stack*/
1976 #endif
1977 NULL, &server_static_cbinfo, errstr);
1978 if (rc != OK) return rc;
1979 cbinfo = server_static_cbinfo;
1980
1981 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
1982 return FAIL;
1983
1984 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1985 were historically separated by underscores. So that I can use either form in my
1986 tests, and also for general convenience, we turn underscores into hyphens here.
1987 */
1988
1989 if (expciphers)
1990 {
1991 uschar * s = expciphers;
1992 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1993 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
1994 if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
1995 return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
1996 cbinfo->server_cipher_list = expciphers;
1997 }
1998
1999 /* If this is a host for which certificate verification is mandatory or
2000 optional, set up appropriately. */
2001
2002 tls_in.certificate_verified = FALSE;
2003 #ifdef SUPPORT_DANE
2004 tls_in.dane_verified = FALSE;
2005 #endif
2006 server_verify_callback_called = FALSE;
2007
2008 if (verify_check_host(&tls_verify_hosts) == OK)
2009 {
2010 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2011 FALSE, verify_callback_server, errstr);
2012 if (rc != OK) return rc;
2013 server_verify_optional = FALSE;
2014 }
2015 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2016 {
2017 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2018 TRUE, verify_callback_server, errstr);
2019 if (rc != OK) return rc;
2020 server_verify_optional = TRUE;
2021 }
2022
2023 /* Prepare for new connection */
2024
2025 if (!(server_ssl = SSL_new(server_ctx)))
2026 return tls_error(US"SSL_new", NULL, NULL, errstr);
2027
2028 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2029 *
2030 * With the SSL_clear(), we get strange interoperability bugs with
2031 * OpenSSL 1.0.1b and TLS1.1/1.2. It looks as though this may be a bug in
2032 * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2033 *
2034 * The SSL_clear() call is to let an existing SSL* be reused, typically after
2035 * session shutdown. In this case, we have a brand new object and there's no
2036 * obvious reason to immediately clear it. I'm guessing that this was
2037 * originally added because of incomplete initialisation which the clear fixed,
2038 * in some historic release.
2039 */
2040
2041 /* Set context and tell client to go ahead, except in the case of TLS startup
2042 on connection, where outputting anything now upsets the clients and tends to
2043 make them disconnect. We need to have an explicit fflush() here, to force out
2044 the response. Other smtp_printf() calls do not need it, because in non-TLS
2045 mode, the fflush() happens when smtp_getc() is called. */
2046
2047 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2048 if (!tls_in.on_connect)
2049 {
2050 smtp_printf("220 TLS go ahead\r\n", FALSE);
2051 fflush(smtp_out);
2052 }
2053
2054 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2055 that the OpenSSL library doesn't. */
2056
2057 SSL_set_wfd(server_ssl, fileno(smtp_out));
2058 SSL_set_rfd(server_ssl, fileno(smtp_in));
2059 SSL_set_accept_state(server_ssl);
2060
2061 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2062
2063 sigalrm_seen = FALSE;
2064 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2065 rc = SSL_accept(server_ssl);
2066 alarm(0);
2067
2068 if (rc <= 0)
2069 {
2070 (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2071 return FAIL;
2072 }
2073
2074 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2075
2076 /* TLS has been set up. Adjust the input functions to read via TLS,
2077 and initialize things. */
2078
2079 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2080
2081 construct_cipher_name(server_ssl, cipherbuf, sizeof(cipherbuf), &tls_in.bits);
2082 tls_in.cipher = cipherbuf;
2083
2084 DEBUG(D_tls)
2085 {
2086 uschar buf[2048];
2087 if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)) != NULL)
2088 debug_printf("Shared ciphers: %s\n", buf);
2089 }
2090
2091 /* Record the certificate we presented */
2092 {
2093 X509 * crt = SSL_get_certificate(server_ssl);
2094 tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2095 }
2096
2097 /* Only used by the server-side tls (tls_in), including tls_getc.
2098 Client-side (tls_out) reads (seem to?) go via
2099 smtp_read_response()/ip_recv().
2100 Hence no need to duplicate for _in and _out.
2101 */
2102 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2103 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2104 ssl_xfer_eof = ssl_xfer_error = FALSE;
2105
2106 receive_getc = tls_getc;
2107 receive_getbuf = tls_getbuf;
2108 receive_get_cache = tls_get_cache;
2109 receive_ungetc = tls_ungetc;
2110 receive_feof = tls_feof;
2111 receive_ferror = tls_ferror;
2112 receive_smtp_buffered = tls_smtp_buffered;
2113
2114 tls_in.active = fileno(smtp_out);
2115 return OK;
2116 }
2117
2118
2119
2120
2121 static int
2122 tls_client_basic_ctx_init(SSL_CTX * ctx,
2123 host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2124 uschar ** errstr)
2125 {
2126 int rc;
2127 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2128 set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2129 the specified host patterns if one of them is defined */
2130
2131 if ( ( !ob->tls_verify_hosts
2132 && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2133 )
2134 || (verify_check_given_host(&ob->tls_verify_hosts, host) == OK)
2135 )
2136 client_verify_optional = FALSE;
2137 else if (verify_check_given_host(&ob->tls_try_verify_hosts, host) == OK)
2138 client_verify_optional = TRUE;
2139 else
2140 return OK;
2141
2142 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2143 ob->tls_crl, host, client_verify_optional, verify_callback_client,
2144 errstr)) != OK)
2145 return rc;
2146
2147 if (verify_check_given_host(&ob->tls_verify_cert_hostnames, host) == OK)
2148 {
2149 cbinfo->verify_cert_hostnames =
2150 #ifdef SUPPORT_I18N
2151 string_domain_utf8_to_alabel(host->name, NULL);
2152 #else
2153 host->name;
2154 #endif
2155 DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2156 cbinfo->verify_cert_hostnames);
2157 }
2158 return OK;
2159 }
2160
2161
2162 #ifdef SUPPORT_DANE
2163 static int
2164 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2165 {
2166 dns_record * rr;
2167 dns_scan dnss;
2168 const char * hostnames[2] = { CS host->name, NULL };
2169 int found = 0;
2170
2171 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2172 return tls_error(US"hostnames load", host, NULL, errstr);
2173
2174 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
2175 rr;
2176 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2177 ) if (rr->type == T_TLSA)
2178 {
2179 const uschar * p = rr->data;
2180 uint8_t usage, selector, mtype;
2181 const char * mdname;
2182
2183 usage = *p++;
2184
2185 /* Only DANE-TA(2) and DANE-EE(3) are supported */
2186 if (usage != 2 && usage != 3) continue;
2187
2188 selector = *p++;
2189 mtype = *p++;
2190
2191 switch (mtype)
2192 {
2193 default: continue; /* Only match-types 0, 1, 2 are supported */
2194 case 0: mdname = NULL; break;
2195 case 1: mdname = "sha256"; break;
2196 case 2: mdname = "sha512"; break;
2197 }
2198
2199 found++;
2200 switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2201 {
2202 default:
2203 return tls_error(US"tlsa load", host, NULL, errstr);
2204 case 0: /* action not taken */
2205 case 1: break;
2206 }
2207
2208 tls_out.tlsa_usage |= 1<<usage;
2209 }
2210
2211 if (found)
2212 return OK;
2213
2214 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2215 return DEFER;
2216 }
2217 #endif /*SUPPORT_DANE*/
2218
2219
2220
2221 /*************************************************
2222 * Start a TLS session in a client *
2223 *************************************************/
2224
2225 /* Called from the smtp transport after STARTTLS has been accepted.
2226
2227 Argument:
2228 fd the fd of the connection
2229 host connected host (for messages)
2230 addr the first address
2231 tb transport (always smtp)
2232 tlsa_dnsa tlsa lookup, if DANE, else null
2233 errstr error string pointer
2234
2235 Returns: OK on success
2236 FAIL otherwise - note that tls_error() will not give DEFER
2237 because this is not a server
2238 */
2239
2240 int
2241 tls_client_start(int fd, host_item *host, address_item *addr,
2242 transport_instance * tb,
2243 #ifdef SUPPORT_DANE
2244 dns_answer * tlsa_dnsa,
2245 #endif
2246 uschar ** errstr)
2247 {
2248 smtp_transport_options_block * ob =
2249 (smtp_transport_options_block *)tb->options_block;
2250 static uschar peerdn[256];
2251 uschar * expciphers;
2252 int rc;
2253 static uschar cipherbuf[256];
2254
2255 #ifndef DISABLE_OCSP
2256 BOOL request_ocsp = FALSE;
2257 BOOL require_ocsp = FALSE;
2258 #endif
2259
2260 #ifdef SUPPORT_DANE
2261 tls_out.tlsa_usage = 0;
2262 #endif
2263
2264 #ifndef DISABLE_OCSP
2265 {
2266 # ifdef SUPPORT_DANE
2267 if ( tlsa_dnsa
2268 && ob->hosts_request_ocsp[0] == '*'
2269 && ob->hosts_request_ocsp[1] == '\0'
2270 )
2271 {
2272 /* Unchanged from default. Use a safer one under DANE */
2273 request_ocsp = TRUE;
2274 ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2275 " {= {4}{$tls_out_tlsa_usage}} } "
2276 " {*}{}}";
2277 }
2278 # endif
2279
2280 if ((require_ocsp =
2281 verify_check_given_host(&ob->hosts_require_ocsp, host) == OK))
2282 request_ocsp = TRUE;
2283 else
2284 # ifdef SUPPORT_DANE
2285 if (!request_ocsp)
2286 # endif
2287 request_ocsp =
2288 verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
2289 }
2290 #endif
2291
2292 rc = tls_init(&client_ctx, host, NULL,
2293 ob->tls_certificate, ob->tls_privatekey,
2294 #ifndef DISABLE_OCSP
2295 (void *)(long)request_ocsp,
2296 #endif
2297 addr, &client_static_cbinfo, errstr);
2298 if (rc != OK) return rc;
2299
2300 tls_out.certificate_verified = FALSE;
2301 client_verify_callback_called = FALSE;
2302
2303 expciphers = NULL;
2304 #ifdef SUPPORT_DANE
2305 if (tlsa_dnsa)
2306 {
2307 /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
2308 other failures should be treated as problems. */
2309 if (ob->dane_require_tls_ciphers &&
2310 !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2311 &expciphers, errstr))
2312 return FAIL;
2313 if (expciphers && *expciphers == '\0')
2314 expciphers = NULL;
2315 }
2316 #endif
2317 if (!expciphers &&
2318 !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
2319 &expciphers, errstr))
2320 return FAIL;
2321
2322 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2323 are separated by underscores. So that I can use either form in my tests, and
2324 also for general convenience, we turn underscores into hyphens here. */
2325
2326 if (expciphers)
2327 {
2328 uschar *s = expciphers;
2329 while (*s) { if (*s == '_') *s = '-'; s++; }
2330 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2331 if (!SSL_CTX_set_cipher_list(client_ctx, CS expciphers))
2332 return tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
2333 }
2334
2335 #ifdef SUPPORT_DANE
2336 if (tlsa_dnsa)
2337 {
2338 SSL_CTX_set_verify(client_ctx,
2339 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2340 verify_callback_client_dane);
2341
2342 if (!DANESSL_library_init())
2343 return tls_error(US"library init", host, NULL, errstr);
2344 if (DANESSL_CTX_init(client_ctx) <= 0)
2345 return tls_error(US"context init", host, NULL, errstr);
2346 }
2347 else
2348
2349 #endif
2350
2351 if ((rc = tls_client_basic_ctx_init(client_ctx, host, ob,
2352 client_static_cbinfo, errstr)) != OK)
2353 return rc;
2354
2355 if ((client_ssl = SSL_new(client_ctx)) == NULL)
2356 return tls_error(US"SSL_new", host, NULL, errstr);
2357 SSL_set_session_id_context(client_ssl, sid_ctx, Ustrlen(sid_ctx));
2358 SSL_set_fd(client_ssl, fd);
2359 SSL_set_connect_state(client_ssl);
2360
2361 if (ob->tls_sni)
2362 {
2363 if (!expand_check(ob->tls_sni, US"tls_sni", &tls_out.sni, errstr))
2364 return FAIL;
2365 if (!tls_out.sni)
2366 {
2367 DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
2368 }
2369 else if (!Ustrlen(tls_out.sni))
2370 tls_out.sni = NULL;
2371 else
2372 {
2373 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2374 DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tls_out.sni);
2375 SSL_set_tlsext_host_name(client_ssl, tls_out.sni);
2376 #else
2377 log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
2378 tls_out.sni);
2379 #endif
2380 }
2381 }
2382
2383 #ifdef SUPPORT_DANE
2384 if (tlsa_dnsa)
2385 if ((rc = dane_tlsa_load(client_ssl, host, tlsa_dnsa, errstr)) != OK)
2386 return rc;
2387 #endif
2388
2389 #ifndef DISABLE_OCSP
2390 /* Request certificate status at connection-time. If the server
2391 does OCSP stapling we will get the callback (set in tls_init()) */
2392 # ifdef SUPPORT_DANE
2393 if (request_ocsp)
2394 {
2395 const uschar * s;
2396 if ( ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2397 || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2398 )
2399 { /* Re-eval now $tls_out_tlsa_usage is populated. If
2400 this means we avoid the OCSP request, we wasted the setup
2401 cost in tls_init(). */
2402 require_ocsp = verify_check_given_host(&ob->hosts_require_ocsp, host) == OK;
2403 request_ocsp = require_ocsp
2404 || verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
2405 }
2406 }
2407 # endif
2408
2409 if (request_ocsp)
2410 {
2411 SSL_set_tlsext_status_type(client_ssl, TLSEXT_STATUSTYPE_ocsp);
2412 client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
2413 tls_out.ocsp = OCSP_NOT_RESP;
2414 }
2415 #endif
2416
2417 #ifndef DISABLE_EVENT
2418 client_static_cbinfo->event_action = tb->event_action;
2419 #endif
2420
2421 /* There doesn't seem to be a built-in timeout on connection. */
2422
2423 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
2424 sigalrm_seen = FALSE;
2425 alarm(ob->command_timeout);
2426 rc = SSL_connect(client_ssl);
2427 alarm(0);
2428
2429 #ifdef SUPPORT_DANE
2430 if (tlsa_dnsa)
2431 DANESSL_cleanup(client_ssl);
2432 #endif
2433
2434 if (rc <= 0)
2435 return tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL,
2436 errstr);
2437
2438 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
2439
2440 peer_cert(client_ssl, &tls_out, peerdn, sizeof(peerdn));
2441
2442 construct_cipher_name(client_ssl, cipherbuf, sizeof(cipherbuf), &tls_out.bits);
2443 tls_out.cipher = cipherbuf;
2444
2445 /* Record the certificate we presented */
2446 {
2447 X509 * crt = SSL_get_certificate(client_ssl);
2448 tls_out.ourcert = crt ? X509_dup(crt) : NULL;
2449 }
2450
2451 tls_out.active = fd;
2452 return OK;
2453 }
2454
2455
2456
2457
2458
2459 static BOOL
2460 tls_refill(unsigned lim)
2461 {
2462 int error;
2463 int inbytes;
2464
2465 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
2466 ssl_xfer_buffer, ssl_xfer_buffer_size);
2467
2468 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2469 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
2470 MIN(ssl_xfer_buffer_size, lim));
2471 error = SSL_get_error(server_ssl, inbytes);
2472 alarm(0);
2473
2474 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
2475 closed down, not that the socket itself has been closed down. Revert to
2476 non-SSL handling. */
2477
2478 if (error == SSL_ERROR_ZERO_RETURN)
2479 {
2480 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2481
2482 receive_getc = smtp_getc;
2483 receive_getbuf = smtp_getbuf;
2484 receive_get_cache = smtp_get_cache;
2485 receive_ungetc = smtp_ungetc;
2486 receive_feof = smtp_feof;
2487 receive_ferror = smtp_ferror;
2488 receive_smtp_buffered = smtp_buffered;
2489
2490 if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
2491 SSL_shutdown(server_ssl);
2492
2493 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
2494 SSL_free(server_ssl);
2495 SSL_CTX_free(server_ctx);
2496 server_static_cbinfo->verify_stack = NULL;
2497 server_ctx = NULL;
2498 server_ssl = NULL;
2499 tls_in.active = -1;
2500 tls_in.bits = 0;
2501 tls_in.cipher = NULL;
2502 tls_in.peerdn = NULL;
2503 tls_in.sni = NULL;
2504
2505 return FALSE;
2506 }
2507
2508 /* Handle genuine errors */
2509
2510 else if (error == SSL_ERROR_SSL)
2511 {
2512 ERR_error_string(ERR_get_error(), ssl_errstring);
2513 log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
2514 ssl_xfer_error = TRUE;
2515 return FALSE;
2516 }
2517
2518 else if (error != SSL_ERROR_NONE)
2519 {
2520 DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
2521 ssl_xfer_error = TRUE;
2522 return FALSE;
2523 }
2524
2525 #ifndef DISABLE_DKIM
2526 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
2527 #endif
2528 ssl_xfer_buffer_hwm = inbytes;
2529 ssl_xfer_buffer_lwm = 0;
2530 return TRUE;
2531 }
2532
2533
2534 /*************************************************
2535 * TLS version of getc *
2536 *************************************************/
2537
2538 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
2539 it refills the buffer via the SSL reading function.
2540
2541 Arguments: lim Maximum amount to read/buffer
2542 Returns: the next character or EOF
2543
2544 Only used by the server-side TLS.
2545 */
2546
2547 int
2548 tls_getc(unsigned lim)
2549 {
2550 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2551 if (!tls_refill(lim))
2552 return ssl_xfer_error ? EOF : smtp_getc(lim);
2553
2554 /* Something in the buffer; return next uschar */
2555
2556 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
2557 }
2558
2559 uschar *
2560 tls_getbuf(unsigned * len)
2561 {
2562 unsigned size;
2563 uschar * buf;
2564
2565 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2566 if (!tls_refill(*len))
2567 {
2568 if (!ssl_xfer_error) return smtp_getbuf(len);
2569 *len = 0;
2570 return NULL;
2571 }
2572
2573 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
2574 size = *len;
2575 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
2576 ssl_xfer_buffer_lwm += size;
2577 *len = size;
2578 return buf;
2579 }
2580
2581
2582 void
2583 tls_get_cache()
2584 {
2585 #ifndef DISABLE_DKIM
2586 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
2587 if (n > 0)
2588 dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
2589 #endif
2590 }
2591
2592
2593 BOOL
2594 tls_could_read(void)
2595 {
2596 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
2597 }
2598
2599
2600 /*************************************************
2601 * Read bytes from TLS channel *
2602 *************************************************/
2603
2604 /*
2605 Arguments:
2606 buff buffer of data
2607 len size of buffer
2608
2609 Returns: the number of bytes read
2610 -1 after a failed read
2611
2612 Only used by the client-side TLS.
2613 */
2614
2615 int
2616 tls_read(BOOL is_server, uschar *buff, size_t len)
2617 {
2618 SSL *ssl = is_server ? server_ssl : client_ssl;
2619 int inbytes;
2620 int error;
2621
2622 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
2623 buff, (unsigned int)len);
2624
2625 inbytes = SSL_read(ssl, CS buff, len);
2626 error = SSL_get_error(ssl, inbytes);
2627
2628 if (error == SSL_ERROR_ZERO_RETURN)
2629 {
2630 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2631 return -1;
2632 }
2633 else if (error != SSL_ERROR_NONE)
2634 return -1;
2635
2636 return inbytes;
2637 }
2638
2639
2640
2641
2642
2643 /*************************************************
2644 * Write bytes down TLS channel *
2645 *************************************************/
2646
2647 /*
2648 Arguments:
2649 is_server channel specifier
2650 buff buffer of data
2651 len number of bytes
2652 more further data expected soon
2653
2654 Returns: the number of bytes after a successful write,
2655 -1 after a failed write
2656
2657 Used by both server-side and client-side TLS.
2658 */
2659
2660 int
2661 tls_write(BOOL is_server, const uschar *buff, size_t len, BOOL more)
2662 {
2663 int outbytes, error, left;
2664 SSL *ssl = is_server ? server_ssl : client_ssl;
2665 static gstring * corked = NULL;
2666
2667 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
2668 buff, (unsigned long)len, more ? ", more" : "");
2669
2670 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
2671 "more" is notified. This hack is only ok if small amounts are involved AND only
2672 one stream does it, in one context (i.e. no store reset). Currently it is used
2673 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only. */
2674
2675 if (is_server && (more || corked))
2676 {
2677 corked = string_catn(corked, buff, len);
2678 if (more)
2679 return len;
2680 buff = CUS corked->s;
2681 len = corked->ptr;
2682 corked = NULL;
2683 }
2684
2685 for (left = len; left > 0;)
2686 {
2687 DEBUG(D_tls) debug_printf("SSL_write(SSL, %p, %d)\n", buff, left);
2688 outbytes = SSL_write(ssl, CS buff, left);
2689 error = SSL_get_error(ssl, outbytes);
2690 DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
2691 switch (error)
2692 {
2693 case SSL_ERROR_SSL:
2694 ERR_error_string(ERR_get_error(), ssl_errstring);
2695 log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
2696 return -1;
2697
2698 case SSL_ERROR_NONE:
2699 left -= outbytes;
2700 buff += outbytes;
2701 break;
2702
2703 case SSL_ERROR_ZERO_RETURN:
2704 log_write(0, LOG_MAIN, "SSL channel closed on write");
2705 return -1;
2706
2707 case SSL_ERROR_SYSCALL:
2708 log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
2709 sender_fullhost ? sender_fullhost : US"<unknown>",
2710 strerror(errno));
2711 return -1;
2712
2713 default:
2714 log_write(0, LOG_MAIN, "SSL_write error %d", error);
2715 return -1;
2716 }
2717 }
2718 return len;
2719 }
2720
2721
2722
2723 /*************************************************
2724 * Close down a TLS session *
2725 *************************************************/
2726
2727 /* This is also called from within a delivery subprocess forked from the
2728 daemon, to shut down the TLS library, without actually doing a shutdown (which
2729 would tamper with the SSL session in the parent process).
2730
2731 Arguments:
2732 shutdown 1 if TLS close-alert is to be sent,
2733 2 if also response to be waited for
2734
2735 Returns: nothing
2736
2737 Used by both server-side and client-side TLS.
2738 */
2739
2740 void
2741 tls_close(BOOL is_server, int shutdown)
2742 {
2743 SSL_CTX **ctxp = is_server ? &server_ctx : &client_ctx;
2744 SSL **sslp = is_server ? &server_ssl : &client_ssl;
2745 int *fdp = is_server ? &tls_in.active : &tls_out.active;
2746
2747 if (*fdp < 0) return; /* TLS was not active */
2748
2749 if (shutdown)
2750 {
2751 int rc;
2752 DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
2753 shutdown > 1 ? " (with response-wait)" : "");
2754
2755 if ( (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
2756 && shutdown > 1)
2757 {
2758 alarm(2);
2759 rc = SSL_shutdown(*sslp); /* wait for response */
2760 alarm(0);
2761 }
2762
2763 if (rc < 0) DEBUG(D_tls)
2764 {
2765 ERR_error_string(ERR_get_error(), ssl_errstring);
2766 debug_printf("SSL_shutdown: %s\n", ssl_errstring);
2767 }
2768 }
2769
2770 if (is_server)
2771 {
2772 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
2773 server_static_cbinfo->verify_stack = NULL;
2774 }
2775
2776 SSL_CTX_free(*ctxp);
2777 SSL_free(*sslp);
2778 *ctxp = NULL;
2779 *sslp = NULL;
2780 *fdp = -1;
2781 }
2782
2783
2784
2785
2786 /*************************************************
2787 * Let tls_require_ciphers be checked at startup *
2788 *************************************************/
2789
2790 /* The tls_require_ciphers option, if set, must be something which the
2791 library can parse.
2792
2793 Returns: NULL on success, or error message
2794 */
2795
2796 uschar *
2797 tls_validate_require_cipher(void)
2798 {
2799 SSL_CTX *ctx;
2800 uschar *s, *expciphers, *err;
2801
2802 /* this duplicates from tls_init(), we need a better "init just global
2803 state, for no specific purpose" singleton function of our own */
2804
2805 SSL_load_error_strings();
2806 OpenSSL_add_ssl_algorithms();
2807 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
2808 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
2809 list of available digests. */
2810 EVP_add_digest(EVP_sha256());
2811 #endif
2812
2813 if (!(tls_require_ciphers && *tls_require_ciphers))
2814 return NULL;
2815
2816 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
2817 &err))
2818 return US"failed to expand tls_require_ciphers";
2819
2820 if (!(expciphers && *expciphers))
2821 return NULL;
2822
2823 /* normalisation ripped from above */
2824 s = expciphers;
2825 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2826
2827 err = NULL;
2828
2829 ctx = SSL_CTX_new(SSLv23_server_method());
2830 if (!ctx)
2831 {
2832 ERR_error_string(ERR_get_error(), ssl_errstring);
2833 return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
2834 }
2835
2836 DEBUG(D_tls)
2837 debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
2838
2839 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
2840 {
2841 ERR_error_string(ERR_get_error(), ssl_errstring);
2842 err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
2843 expciphers, ssl_errstring);
2844 }
2845
2846 SSL_CTX_free(ctx);
2847
2848 return err;
2849 }
2850
2851
2852
2853
2854 /*************************************************
2855 * Report the library versions. *
2856 *************************************************/
2857
2858 /* There have historically been some issues with binary compatibility in
2859 OpenSSL libraries; if Exim (like many other applications) is built against
2860 one version of OpenSSL but the run-time linker picks up another version,
2861 it can result in serious failures, including crashing with a SIGSEGV. So
2862 report the version found by the compiler and the run-time version.
2863
2864 Note: some OS vendors backport security fixes without changing the version
2865 number/string, and the version date remains unchanged. The _build_ date
2866 will change, so we can more usefully assist with version diagnosis by also
2867 reporting the build date.
2868
2869 Arguments: a FILE* to print the results to
2870 Returns: nothing
2871 */
2872
2873 void
2874 tls_version_report(FILE *f)
2875 {
2876 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
2877 " Runtime: %s\n"
2878 " : %s\n",
2879 OPENSSL_VERSION_TEXT,
2880 SSLeay_version(SSLEAY_VERSION),
2881 SSLeay_version(SSLEAY_BUILT_ON));
2882 /* third line is 38 characters for the %s and the line is 73 chars long;
2883 the OpenSSL output includes a "built on: " prefix already. */
2884 }
2885
2886
2887
2888
2889 /*************************************************
2890 * Random number generation *
2891 *************************************************/
2892
2893 /* Pseudo-random number generation. The result is not expected to be
2894 cryptographically strong but not so weak that someone will shoot themselves
2895 in the foot using it as a nonce in input in some email header scheme or
2896 whatever weirdness they'll twist this into. The result should handle fork()
2897 and avoid repeating sequences. OpenSSL handles that for us.
2898
2899 Arguments:
2900 max range maximum
2901 Returns a random number in range [0, max-1]
2902 */
2903
2904 int
2905 vaguely_random_number(int max)
2906 {
2907 unsigned int r;
2908 int i, needed_len;
2909 static pid_t pidlast = 0;
2910 pid_t pidnow;
2911 uschar *p;
2912 uschar smallbuf[sizeof(r)];
2913
2914 if (max <= 1)
2915 return 0;
2916
2917 pidnow = getpid();
2918 if (pidnow != pidlast)
2919 {
2920 /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
2921 is unique for each thread", this doesn't apparently apply across processes,
2922 so our own warning from vaguely_random_number_fallback() applies here too.
2923 Fix per PostgreSQL. */
2924 if (pidlast != 0)
2925 RAND_cleanup();
2926 pidlast = pidnow;
2927 }
2928
2929 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
2930 if (!RAND_status())
2931 {
2932 randstuff r;
2933 gettimeofday(&r.tv, NULL);
2934 r.p = getpid();
2935
2936 RAND_seed(US (&r), sizeof(r));
2937 }
2938 /* We're after pseudo-random, not random; if we still don't have enough data
2939 in the internal PRNG then our options are limited. We could sleep and hope
2940 for entropy to come along (prayer technique) but if the system is so depleted
2941 in the first place then something is likely to just keep taking it. Instead,
2942 we'll just take whatever little bit of pseudo-random we can still manage to
2943 get. */
2944
2945 needed_len = sizeof(r);
2946 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
2947 asked for a number less than 10. */
2948 for (r = max, i = 0; r; ++i)
2949 r >>= 1;
2950 i = (i + 7) / 8;
2951 if (i < needed_len)
2952 needed_len = i;
2953
2954 #ifdef EXIM_HAVE_RAND_PSEUDO
2955 /* We do not care if crypto-strong */
2956 i = RAND_pseudo_bytes(smallbuf, needed_len);
2957 #else
2958 i = RAND_bytes(smallbuf, needed_len);
2959 #endif
2960
2961 if (i < 0)
2962 {
2963 DEBUG(D_all)
2964 debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
2965 return vaguely_random_number_fallback(max);
2966 }
2967
2968 r = 0;
2969 for (p = smallbuf; needed_len; --needed_len, ++p)
2970 {
2971 r *= 256;
2972 r += *p;
2973 }
2974
2975 /* We don't particularly care about weighted results; if someone wants
2976 smooth distribution and cares enough then they should submit a patch then. */
2977 return r % max;
2978 }
2979
2980
2981
2982
2983 /*************************************************
2984 * OpenSSL option parse *
2985 *************************************************/
2986
2987 /* Parse one option for tls_openssl_options_parse below
2988
2989 Arguments:
2990 name one option name
2991 value place to store a value for it
2992 Returns success or failure in parsing
2993 */
2994
2995 struct exim_openssl_option {
2996 uschar *name;
2997 long value;
2998 };
2999 /* We could use a macro to expand, but we need the ifdef and not all the
3000 options document which version they were introduced in. Policylet: include
3001 all options unless explicitly for DTLS, let the administrator choose which
3002 to apply.
3003
3004 This list is current as of:
3005 ==> 1.0.1b <==
3006 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
3007 */
3008 static struct exim_openssl_option exim_openssl_options[] = {
3009 /* KEEP SORTED ALPHABETICALLY! */
3010 #ifdef SSL_OP_ALL
3011 { US"all", SSL_OP_ALL },
3012 #endif
3013 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
3014 { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
3015 #endif
3016 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
3017 { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
3018 #endif
3019 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
3020 { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
3021 #endif
3022 #ifdef SSL_OP_EPHEMERAL_RSA
3023 { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
3024 #endif
3025 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
3026 { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
3027 #endif
3028 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
3029 { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
3030 #endif
3031 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
3032 { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
3033 #endif
3034 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
3035 { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
3036 #endif
3037 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
3038 { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
3039 #endif
3040 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
3041 { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
3042 #endif
3043 #ifdef SSL_OP_NO_COMPRESSION
3044 { US"no_compression", SSL_OP_NO_COMPRESSION },
3045 #endif
3046 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
3047 { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
3048 #endif
3049 #ifdef SSL_OP_NO_SSLv2
3050 { US"no_sslv2", SSL_OP_NO_SSLv2 },
3051 #endif
3052 #ifdef SSL_OP_NO_SSLv3
3053 { US"no_sslv3", SSL_OP_NO_SSLv3 },
3054 #endif
3055 #ifdef SSL_OP_NO_TICKET
3056 { US"no_ticket", SSL_OP_NO_TICKET },
3057 #endif
3058 #ifdef SSL_OP_NO_TLSv1
3059 { US"no_tlsv1", SSL_OP_NO_TLSv1 },
3060 #endif
3061 #ifdef SSL_OP_NO_TLSv1_1
3062 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
3063 /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
3064 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
3065 #else
3066 { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
3067 #endif
3068 #endif
3069 #ifdef SSL_OP_NO_TLSv1_2
3070 { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
3071 #endif
3072 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
3073 { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
3074 #endif
3075 #ifdef SSL_OP_SINGLE_DH_USE
3076 { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
3077 #endif
3078 #ifdef SSL_OP_SINGLE_ECDH_USE
3079 { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
3080 #endif
3081 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
3082 { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
3083 #endif
3084 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
3085 { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
3086 #endif
3087 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
3088 { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
3089 #endif
3090 #ifdef SSL_OP_TLS_D5_BUG
3091 { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
3092 #endif
3093 #ifdef SSL_OP_TLS_ROLLBACK_BUG
3094 { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
3095 #endif
3096 };
3097 static int exim_openssl_options_size =
3098 sizeof(exim_openssl_options)/sizeof(struct exim_openssl_option);
3099
3100
3101 static BOOL
3102 tls_openssl_one_option_parse(uschar *name, long *value)
3103 {
3104 int first = 0;
3105 int last = exim_openssl_options_size;
3106 while (last > first)
3107 {
3108 int middle = (first + last)/2;
3109 int c = Ustrcmp(name, exim_openssl_options[middle].name);
3110 if (c == 0)
3111 {
3112 *value = exim_openssl_options[middle].value;
3113 return TRUE;
3114 }
3115 else if (c > 0)
3116 first = middle + 1;
3117 else
3118 last = middle;
3119 }
3120 return FALSE;
3121 }
3122
3123
3124
3125
3126 /*************************************************
3127 * OpenSSL option parsing logic *
3128 *************************************************/
3129
3130 /* OpenSSL has a number of compatibility options which an administrator might
3131 reasonably wish to set. Interpret a list similarly to decode_bits(), so that
3132 we look like log_selector.
3133
3134 Arguments:
3135 option_spec the administrator-supplied string of options
3136 results ptr to long storage for the options bitmap
3137 Returns success or failure
3138 */
3139
3140 BOOL
3141 tls_openssl_options_parse(uschar *option_spec, long *results)
3142 {
3143 long result, item;
3144 uschar *s, *end;
3145 uschar keep_c;
3146 BOOL adding, item_parsed;
3147
3148 result = SSL_OP_NO_TICKET;
3149 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3150 * from default because it increases BEAST susceptibility. */
3151 #ifdef SSL_OP_NO_SSLv2
3152 result |= SSL_OP_NO_SSLv2;
3153 #endif
3154 #ifdef SSL_OP_SINGLE_DH_USE
3155 result |= SSL_OP_SINGLE_DH_USE;
3156 #endif
3157
3158 if (!option_spec)
3159 {
3160 *results = result;
3161 return TRUE;
3162 }
3163
3164 for (s=option_spec; *s != '\0'; /**/)
3165 {
3166 while (isspace(*s)) ++s;
3167 if (*s == '\0')
3168 break;
3169 if (*s != '+' && *s != '-')
3170 {
3171 DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3172 "+ or - expected but found \"%s\"\n", s);
3173 return FALSE;
3174 }
3175 adding = *s++ == '+';
3176 for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3177 keep_c = *end;
3178 *end = '\0';
3179 item_parsed = tls_openssl_one_option_parse(s, &item);
3180 *end = keep_c;
3181 if (!item_parsed)
3182 {
3183 DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3184 return FALSE;
3185 }
3186 DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
3187 adding ? "adding" : "removing", result, item, s);
3188 if (adding)
3189 result |= item;
3190 else
3191 result &= ~item;
3192 s = end;
3193 }
3194
3195 *results = result;
3196 return TRUE;
3197 }
3198
3199 /* vi: aw ai sw=2
3200 */
3201 /* End of tls-openssl.c */