-
Notifications
You must be signed in to change notification settings - Fork 124
/
tls_client.c
1366 lines (1227 loc) · 45.8 KB
/
tls_client.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*++
/* NAME
/* tls_client
/* SUMMARY
/* client-side TLS engine
/* SYNOPSIS
/* #include <tls.h>
/*
/* TLS_APPL_STATE *tls_client_init(init_props)
/* const TLS_CLIENT_INIT_PROPS *init_props;
/*
/* TLS_SESS_STATE *tls_client_start(start_props)
/* const TLS_CLIENT_START_PROPS *start_props;
/*
/* TLS_SESS_STATE *tls_client_post_connect(TLScontext, start_props)
/* TLS_SESS_STATE *TLScontext;
/* const TLS_CLIENT_START_PROPS *start_props;
/*
/* void tls_client_stop(app_ctx, stream, failure, TLScontext)
/* TLS_APPL_STATE *app_ctx;
/* VSTREAM *stream;
/* int failure;
/* TLS_SESS_STATE *TLScontext;
/* DESCRIPTION
/* This module is the interface between Postfix TLS clients,
/* the OpenSSL library and the TLS entropy and cache manager.
/*
/* The SMTP client will attempt to verify the server hostname
/* against the names listed in the server certificate. When
/* a hostname match is required, the verification fails
/* on certificate verification or hostname mis-match errors.
/* When no hostname match is required, hostname verification
/* failures are logged but they do not affect the TLS handshake
/* or the SMTP session.
/*
/* The rules for peer name wild-card matching differ between
/* RFC 2818 (HTTP over TLS) and RFC 2830 (LDAP over TLS), while
/* RFC RFC3207 (SMTP over TLS) does not specify a rule at all.
/* Postfix uses a restrictive match algorithm. One asterisk
/* ('*') is allowed as the left-most component of a wild-card
/* certificate name; it matches the left-most component of
/* the peer hostname.
/*
/* Another area where RFCs aren't always explicit is the
/* handling of dNSNames in peer certificates. RFC 3207 (SMTP
/* over TLS) does not mention dNSNames. Postfix follows the
/* strict rules in RFC 2818 (HTTP over TLS), section 3.1: The
/* Subject Alternative Name/dNSName has precedence over
/* CommonName. If at least one dNSName is provided, Postfix
/* verifies those against the peer hostname and ignores the
/* CommonName, otherwise Postfix verifies the CommonName
/* against the peer hostname.
/*
/* tls_client_init() is called once when the SMTP client
/* initializes.
/* Certificate details are also decided during this phase,
/* so peer-specific certificate selection is not possible.
/*
/* tls_client_start() activates the TLS session over an established
/* stream. We expect that network buffers are flushed and
/* the TLS handshake can begin immediately.
/*
/* tls_client_stop() sends the "close notify" alert via
/* SSL_shutdown() to the peer and resets all connection specific
/* TLS data. As RFC2487 does not specify a separate shutdown, it
/* is assumed that the underlying TCP connection is shut down
/* immediately afterwards. Any further writes to the channel will
/* be discarded, and any further reads will report end-of-file.
/* If the failure flag is set, no SSL_shutdown() handshake is performed.
/*
/* Once the TLS connection is initiated, information about the TLS
/* state is available via the TLScontext structure:
/* .IP TLScontext->protocol
/* the protocol name (SSLv2, SSLv3, TLSv1),
/* .IP TLScontext->cipher_name
/* the cipher name (e.g. RC4/MD5),
/* .IP TLScontext->cipher_usebits
/* the number of bits actually used (e.g. 40),
/* .IP TLScontext->cipher_algbits
/* the number of bits the algorithm is based on (e.g. 128).
/* .PP
/* The last two values may differ from each other when export-strength
/* encryption is used.
/*
/* If the peer offered a certificate, part of the certificate data are
/* available as:
/* .IP TLScontext->peer_status
/* A bitmask field that records the status of the peer certificate
/* verification. This consists of one or more of TLS_CRED_FLAG_CERT,
/* TLS_CRED_FLAG_RPK, TLS_CERT_FLAG_TRUSTED, TLS_CERT_FLAG_MATCHED and
/* TLS_CERT_FLAG_SECURED.
/* .IP TLScontext->peer_CN
/* Extracted CommonName of the peer, or zero-length string if the
/* information could not be extracted.
/* .IP TLScontext->issuer_CN
/* Extracted CommonName of the issuer, or zero-length string if the
/* information could not be extracted.
/* .IP TLScontext->peer_cert_fprint
/* At the fingerprint security level, if the peer presented a certificate
/* the fingerprint of the certificate.
/* .PP
/* If no peer certificate is presented the peer_status is set to 0.
/* EVENT_DRIVEN APPLICATIONS
/* .ad
/* .fi
/* Event-driven programs manage multiple I/O channels. Such
/* programs cannot use the synchronous VSTREAM-over-TLS
/* implementation that the TLS library historically provides,
/* including tls_client_stop() and the underlying tls_stream(3)
/* and tls_bio_ops(3) routines.
/*
/* With the current TLS library implementation, this means
/* that an event-driven application is responsible for calling
/* and retrying SSL_connect(), SSL_read(), SSL_write() and
/* SSL_shutdown().
/*
/* To maintain control over TLS I/O, an event-driven client
/* invokes tls_client_start() with a null VSTREAM argument and
/* with an fd argument that specifies the I/O file descriptor.
/* Then, tls_client_start() performs all the necessary
/* preparations before the TLS handshake and returns a partially
/* populated TLS context. The event-driven application is then
/* responsible for invoking SSL_connect(), and if successful,
/* for invoking tls_client_post_connect() to finish the work
/* that was started by tls_client_start(). In case of unrecoverable
/* failure, tls_client_post_connect() destroys the TLS context
/* and returns a null pointer value.
/* LICENSE
/* .ad
/* .fi
/* This software is free. You can do with it whatever you want.
/* The original author kindly requests that you acknowledge
/* the use of his software.
/* AUTHOR(S)
/* Originally written by:
/* Lutz Jaenicke
/* BTU Cottbus
/* Allgemeine Elektrotechnik
/* Universitaetsplatz 3-4
/* D-03044 Cottbus, Germany
/*
/* Updated by:
/* Wietse Venema
/* IBM T.J. Watson Research
/* P.O. Box 704
/* Yorktown Heights, NY 10598, USA
/*
/* Wietse Venema
/* Google, Inc.
/* 111 8th Avenue
/* New York, NY 10011, USA
/*
/* Victor Duchovni
/* Morgan Stanley
/*--*/
/* System library. */
#include <sys_defs.h>
#ifdef USE_TLS
#include <string.h>
#ifdef STRCASECMP_IN_STRINGS_H
#include <strings.h>
#endif
/* Utility library. */
#include <argv.h>
#include <mymalloc.h>
#include <vstring.h>
#include <vstream.h>
#include <stringops.h>
#include <msg.h>
#include <iostuff.h> /* non-blocking */
#include <midna_domain.h>
/* Global library. */
#include <mail_params.h>
/* TLS library. */
#include <tls_mgr.h>
#define TLS_INTERNAL
#include <tls.h>
/* Application-specific. */
#define STR vstring_str
#define LEN VSTRING_LEN
/* load_clnt_session - load session from client cache (non-callback) */
static SSL_SESSION *load_clnt_session(TLS_SESS_STATE *TLScontext)
{
const char *myname = "load_clnt_session";
SSL_SESSION *session = 0;
VSTRING *session_data = vstring_alloc(2048);
/*
* Prepare the query.
*/
if (TLScontext->log_mask & TLS_LOG_CACHE)
/* serverid contains transport:addr:port information */
msg_info("looking for session %s in %s cache",
TLScontext->serverid, TLScontext->cache_type);
/*
* We only get here if the cache_type is not empty. This code is not
* called unless caching is enabled and the cache_type is stored in the
* server SSL context.
*/
if (TLScontext->cache_type == 0)
msg_panic("%s: null client session cache type in session lookup",
myname);
/*
* Look up and activate the SSL_SESSION object. Errors are non-fatal,
* since caching is only an optimization.
*/
if (tls_mgr_lookup(TLScontext->cache_type, TLScontext->serverid,
session_data) == TLS_MGR_STAT_OK) {
session = tls_session_activate(STR(session_data), LEN(session_data));
if (session) {
if (TLScontext->log_mask & TLS_LOG_CACHE)
/* serverid contains transport:addr:port information */
msg_info("reloaded session %s from %s cache",
TLScontext->serverid, TLScontext->cache_type);
}
}
/*
* Clean up.
*/
vstring_free(session_data);
return (session);
}
/* new_client_session_cb - name new session and save it to client cache */
static int new_client_session_cb(SSL *ssl, SSL_SESSION *session)
{
const char *myname = "new_client_session_cb";
TLS_SESS_STATE *TLScontext;
VSTRING *session_data;
/*
* The cache name (if caching is enabled in tlsmgr(8)) and the cache ID
* string for this session are stored in the TLScontext. It cannot be
* null at this point.
*/
if ((TLScontext = SSL_get_ex_data(ssl, TLScontext_index)) == 0)
msg_panic("%s: null TLScontext in new session callback", myname);
/*
* We only get here if the cache_type is not empty. This callback is not
* set unless caching is enabled and the cache_type is stored in the
* server SSL context.
*/
if (TLScontext->cache_type == 0)
msg_panic("%s: null session cache type in new session callback",
myname);
if (TLScontext->log_mask & TLS_LOG_CACHE)
/* serverid contains transport:addr:port information */
msg_info("save session %s to %s cache",
TLScontext->serverid, TLScontext->cache_type);
/*
* Passivate and save the session object. Errors are non-fatal, since
* caching is only an optimization.
*/
if ((session_data = tls_session_passivate(session)) != 0) {
tls_mgr_update(TLScontext->cache_type, TLScontext->serverid,
STR(session_data), LEN(session_data));
vstring_free(session_data);
}
/*
* Clean up.
*/
SSL_SESSION_free(session); /* 200502 */
return (1);
}
/* uncache_session - remove session from the external cache */
static void uncache_session(SSL_CTX *ctx, TLS_SESS_STATE *TLScontext)
{
SSL_SESSION *session = SSL_get_session(TLScontext->con);
SSL_CTX_remove_session(ctx, session);
if (TLScontext->cache_type == 0 || TLScontext->serverid == 0)
return;
if (TLScontext->log_mask & TLS_LOG_CACHE)
/* serverid contains transport:addr:port information */
msg_info("remove session %s from client cache", TLScontext->serverid);
tls_mgr_delete(TLScontext->cache_type, TLScontext->serverid);
}
/* verify_x509 - process X.509 certificate verification status */
static void verify_x509(TLS_SESS_STATE *TLScontext, X509 *peercert,
const TLS_CLIENT_START_PROPS *props)
{
/*
* On exit both peer_CN and issuer_CN should be set.
*/
TLScontext->issuer_CN = tls_issuer_CN(peercert, TLScontext);
TLScontext->peer_CN = tls_peer_CN(peercert, TLScontext);
/*
* Is the certificate trust chain trusted and matched? Any required name
* checks are now performed internally in OpenSSL.
*/
if (SSL_get_verify_result(TLScontext->con) == X509_V_OK) {
TLScontext->peer_status |= TLS_CERT_FLAG_TRUSTED;
if (TLScontext->must_fail) {
msg_panic("%s: cert valid despite trust init failure",
TLScontext->namaddr);
} else if (TLS_MUST_MATCH(TLScontext->level)) {
/*
* Fully secured only if not insecure like half-dane. We use
* TLS_CERT_FLAG_MATCHED to satisfy policy, but
* TLS_CERT_FLAG_SECURED to log the effective security.
*
* Would ideally also exclude "verify" (as opposed to "secure")
* here, because that can be subject to insecure MX indirection,
* but that's rather incompatible (and not even the case with
* explicitly chosen non-default match patterns). Users have
* been warned.
*/
if (!TLS_NEVER_SECURED(TLScontext->level))
TLScontext->peer_status |= TLS_CERT_FLAG_SECURED;
TLScontext->peer_status |= TLS_CERT_FLAG_MATCHED;
if (TLScontext->log_mask &
(TLS_LOG_CERTMATCH | TLS_LOG_VERBOSE | TLS_LOG_PEERCERT)) {
const char *peername = SSL_get0_peername(TLScontext->con);
if (peername)
msg_info("%s: matched peername: %s",
TLScontext->namaddr, peername);
tls_dane_log(TLScontext);
}
}
}
/*
* Give them a clue. Problems with trust chain verification are logged
* when the session is first negotiated, before the session is stored
* into the cache. We don't want mystery failures, so log the fact the
* real problem is to be found in the past.
*/
if (!TLS_CERT_IS_MATCHED(TLScontext)
&& (TLScontext->log_mask & TLS_LOG_UNTRUSTED)) {
if (TLScontext->session_reused == 0)
tls_log_verify_error(TLScontext);
else
msg_info("%s: re-using session with untrusted peer credential, "
"look for details earlier in the log", props->namaddr);
}
}
/* verify_rpk - process RFC7250 raw public key verification status */
static void verify_rpk(TLS_SESS_STATE *TLScontext, EVP_PKEY *peerpkey,
const TLS_CLIENT_START_PROPS *props)
{
/* Was the raw public key (type of cert) matched? */
if (SSL_get_verify_result(TLScontext->con) == X509_V_OK) {
TLScontext->peer_status |= TLS_CERT_FLAG_TRUSTED;
if (TLScontext->must_fail) {
msg_panic("%s: raw public key valid despite trust init failure",
TLScontext->namaddr);
} else if (TLS_MUST_MATCH(TLScontext->level)) {
/*
* Fully secured only if not insecure like half-dane. We use
* TLS_CERT_FLAG_MATCHED to satisfy policy, but
* TLS_CERT_FLAG_SECURED to log the effective security.
*/
if (!TLS_NEVER_SECURED(TLScontext->level))
TLScontext->peer_status |= TLS_CERT_FLAG_SECURED;
TLScontext->peer_status |= TLS_CERT_FLAG_MATCHED;
if (TLScontext->log_mask &
(TLS_LOG_CERTMATCH | TLS_LOG_VERBOSE | TLS_LOG_PEERCERT))
tls_dane_log(TLScontext);
}
}
/*
* Give them a clue. Problems with trust chain verification are logged
* when the session is first negotiated, before the session is stored
* into the cache. We don't want mystery failures, so log the fact the
* real problem is to be found in the past.
*/
if (!TLS_CERT_IS_MATCHED(TLScontext)
&& (TLScontext->log_mask & TLS_LOG_UNTRUSTED)) {
if (TLScontext->session_reused == 0)
tls_log_verify_error(TLScontext);
else
msg_info("%s: re-using session with untrusted certificate, "
"look for details earlier in the log", props->namaddr);
}
}
/* add_namechecks - tell OpenSSL what names to check */
static void add_namechecks(TLS_SESS_STATE *TLScontext,
const TLS_CLIENT_START_PROPS *props)
{
SSL *ssl = TLScontext->con;
int namechecks_count = 0;
int i;
/* RFC6125: No part-label 'foo*bar.example.com' wildcards for SMTP */
SSL_set_hostflags(ssl, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
for (i = 0; i < props->matchargv->argc; ++i) {
const char *name = props->matchargv->argv[i];
const char *aname;
int match_subdomain = 0;
if (strcasecmp(name, "nexthop") == 0) {
name = props->nexthop;
} else if (strcasecmp(name, "dot-nexthop") == 0) {
name = props->nexthop;
match_subdomain = 1;
} else if (strcasecmp(name, "hostname") == 0) {
name = props->host;
} else {
if (*name == '.') {
if (*++name == 0) {
msg_warn("%s: ignoring invalid match name: \".\"",
TLScontext->namaddr);
continue;
}
match_subdomain = 1;
}
#ifndef NO_EAI
else {
/*
* Besides U+002E (full stop) IDNA2003 allows labels to be
* separated by any of the Unicode variants U+3002
* (ideographic full stop), U+FF0E (fullwidth full stop), and
* U+FF61 (halfwidth ideographic full stop). Their respective
* UTF-8 encodings are: E38082, EFBC8E and EFBDA1.
*
* IDNA2008 does not permit (upper) case and other variant
* differences in U-labels. The midna_domain_to_ascii()
* function, based on UTS46, normalizes such differences
* away.
*
* The IDNA to_ASCII conversion does not allow empty leading
* labels, so we handle these explicitly here.
*/
unsigned char *cp = (unsigned char *) name;
if ((cp[0] == 0xe3 && cp[1] == 0x80 && cp[2] == 0x82)
|| (cp[0] == 0xef && cp[1] == 0xbc && cp[2] == 0x8e)
|| (cp[0] == 0xef && cp[1] == 0xbd && cp[2] == 0xa1)) {
if (name[3]) {
name = name + 3;
match_subdomain = 1;
}
}
}
#endif
}
/*
* DNS subjectAltNames are required to be ASCII.
*
* Per RFC 6125 Section 6.4.4 Matching the CN-ID, follows the same rules
* (6.4.1, 6.4.2 and 6.4.3) that apply to subjectAltNames. In
* particular, 6.4.2 says that the reference identifier is coerced to
* ASCII, but no conversion is stated or implied for the CN-ID, so it
* seems it only matches if it is all ASCII. Otherwise, it is some
* other sort of name.
*/
#ifndef NO_EAI
if (!allascii(name) && (aname = midna_domain_to_ascii(name)) != 0) {
if (msg_verbose)
msg_info("%s asciified to %s", name, aname);
name = aname;
}
#endif
if (!match_subdomain) {
if (SSL_add1_host(ssl, name))
++namechecks_count;
else
msg_warn("%s: error loading match name: \"%s\"",
TLScontext->namaddr, name);
} else {
char *dot_name = concatenate(".", name, (char *) 0);
if (SSL_add1_host(ssl, dot_name))
++namechecks_count;
else
msg_warn("%s: error loading match name: \"%s\"",
TLScontext->namaddr, dot_name);
myfree(dot_name);
}
}
/*
* If we failed to add any names, OpenSSL will perform no namechecks, so
* we set the "must_fail" bit to avoid verification false-positives.
*/
if (namechecks_count == 0) {
msg_warn("%s: could not configure peer name checks",
TLScontext->namaddr);
TLScontext->must_fail = 1;
}
}
/* tls_auth_enable - set up TLS authentication */
static int tls_auth_enable(TLS_SESS_STATE *TLScontext,
const TLS_CLIENT_START_PROPS *props)
{
const char *sni = 0;
if (props->sni && *props->sni) {
#ifndef NO_EAI
const char *aname;
#endif
/*
* MTA-STS policy plugin compatibility: with servername=hostname,
* Postfix must send the MX hostname (not CNAME expanded).
*/
if (strcmp(props->sni, "hostname") == 0)
sni = props->host;
else if (strcmp(props->sni, "nexthop") == 0)
sni = props->nexthop;
else
sni = props->sni;
/*
* The SSL_set_tlsext_host_name() documentation does not promise that
* every implementation will convert U-label form to A-label form.
*/
#ifndef NO_EAI
if (!allascii(sni) && (aname = midna_domain_to_ascii(sni)) != 0) {
if (msg_verbose)
msg_info("%s asciified to %s", sni, aname);
sni = aname;
}
#endif
}
switch (TLScontext->level) {
case TLS_LEV_HALF_DANE:
case TLS_LEV_DANE:
case TLS_LEV_DANE_ONLY:
/*
* With DANE sessions, send an SNI hint. We don't care whether the
* server reports finding a matching certificate or not, so no
* callback is required to process the server response. Our use of
* SNI is limited to giving servers that make use of SNI the best
* opportunity to find the certificate they promised via the
* associated TLSA RRs.
*
* Since the hostname is DNSSEC-validated, it must be a DNS FQDN and
* therefore valid for use with SNI.
*/
if (SSL_dane_enable(TLScontext->con, 0) <= 0) {
msg_warn("%s: error enabling DANE-based certificate validation",
TLScontext->namaddr);
tls_print_errors();
return (0);
}
/* RFC7672 Section 3.1.1 specifies no name checks for DANE-EE(3) */
SSL_dane_set_flags(TLScontext->con, DANE_FLAG_NO_DANE_EE_NAMECHECKS);
/* Per RFC7672 the SNI name is the TLSA base domain */
sni = props->dane->base_domain;
add_namechecks(TLScontext, props);
break;
case TLS_LEV_FPRINT:
/* Synthetic DANE for fingerprint security */
if (SSL_dane_enable(TLScontext->con, 0) <= 0) {
msg_warn("%s: error enabling fingerprint certificate validation",
props->namaddr);
tls_print_errors();
return (0);
}
SSL_dane_set_flags(TLScontext->con, DANE_FLAG_NO_DANE_EE_NAMECHECKS);
break;
case TLS_LEV_SECURE:
case TLS_LEV_VERIFY:
if (TLScontext->dane != 0 && TLScontext->dane->tlsa != 0) {
/* Synthetic DANE for per-destination trust-anchors */
if (SSL_dane_enable(TLScontext->con, NULL) <= 0) {
msg_warn("%s: error configuring local trust anchors",
props->namaddr);
tls_print_errors();
return (0);
}
}
add_namechecks(TLScontext, props);
break;
default:
break;
}
if (sni) {
if (strlen(sni) > TLSEXT_MAXLEN_host_name) {
msg_warn("%s: ignoring too long SNI hostname: %.100s",
props->namaddr, sni);
return (0);
}
/*
* Failure to set a valid SNI hostname is a memory allocation error,
* and thus transient. Since we must not cache the session if we
* failed to send the SNI name, we have little choice but to abort.
*/
if (!SSL_set_tlsext_host_name(TLScontext->con, sni)) {
msg_warn("%s: error setting SNI hostname to: %s", props->namaddr,
sni);
return (0);
}
/*
* The saved value is not presently used client-side, but could later
* be logged if acked by the server (requires new client-side
* callback to detect the ack). For now this just maintains symmetry
* with the server code, where do record the received SNI for
* logging.
*/
TLScontext->peer_sni = mystrdup(sni);
if (TLScontext->log_mask & TLS_LOG_DEBUG)
msg_info("%s: SNI hostname: %s", props->namaddr, sni);
}
return (1);
}
/* tls_client_init - initialize client-side TLS engine */
TLS_APPL_STATE *tls_client_init(const TLS_CLIENT_INIT_PROPS *props)
{
SSL_CTX *client_ctx;
TLS_APPL_STATE *app_ctx;
const EVP_MD *fpt_alg;
long off = 0;
int cachable;
int scache_timeout;
int log_mask;
/*
* Convert user loglevel to internal logmask.
*/
log_mask = tls_log_mask(props->log_param, props->log_level);
if (log_mask & TLS_LOG_VERBOSE)
msg_info("initializing the client-side TLS engine");
/*
* Load (mostly cipher related) TLS-library internal main.cf parameters.
*/
tls_param_init();
/*
* Detect mismatch between compile-time headers and run-time library.
*/
tls_check_version();
/*
* Initialize the OpenSSL library, possibly loading its configuration
* file.
*/
if (tls_library_init() == 0)
return (0);
/*
* Create an application data index for SSL objects, so that we can
* attach TLScontext information; this information is needed inside
* tls_verify_certificate_callback().
*/
if (TLScontext_index < 0) {
if ((TLScontext_index = SSL_get_ex_new_index(0, 0, 0, 0, 0)) < 0) {
msg_warn("Cannot allocate SSL application data index: "
"disabling TLS support");
return (0);
}
}
/*
* If the administrator specifies an unsupported digest algorithm, fail
* now, rather than in the middle of a TLS handshake.
*/
if ((fpt_alg = tls_validate_digest(props->mdalg)) == 0) {
msg_warn("disabling TLS support");
return (0);
}
/*
* Initialize the PRNG (Pseudo Random Number Generator) with some seed
* from external and internal sources. Don't enable TLS without some real
* entropy.
*/
if (tls_ext_seed(var_tls_daemon_rand_bytes) < 0) {
msg_warn("no entropy for TLS key generation: disabling TLS support");
return (0);
}
tls_int_seed();
/*
* The SSL/TLS specifications require the client to send a message in the
* oldest specification it understands with the highest level it
* understands in the message. RFC2487 is only specified for TLSv1, but
* we want to be as compatible as possible, so we will start off with a
* SSLv2 greeting allowing the best we can offer: TLSv1. We can restrict
* this with the options setting later, anyhow.
*/
ERR_clear_error();
client_ctx = SSL_CTX_new(TLS_client_method());
if (client_ctx == 0) {
msg_warn("cannot allocate client SSL_CTX: disabling TLS support");
tls_print_errors();
return (0);
}
#ifdef SSL_SECOP_PEER
/* Backwards compatible security as a base for opportunistic TLS. */
SSL_CTX_set_security_level(client_ctx, 0);
#endif
/*
* See the verify callback in tls_verify.c
*/
SSL_CTX_set_verify_depth(client_ctx, props->verifydepth + 1);
/*
* This is a prerequisite for enabling DANE support in OpenSSL, but not a
* commitment to use DANE, thus suitable for both DANE and non-DANE TLS
* connections. Indeed we need this not just for DANE, but aslo for
* fingerprint and "tafile" support. Since it just allocates memory, it
* should never fail except when we're likely to fail anyway. Rather
* than try to run with crippled TLS support, just give up using TLS.
*/
if (SSL_CTX_dane_enable(client_ctx) <= 0) {
msg_warn("OpenSSL DANE initialization failed: disabling TLS support");
tls_print_errors();
return (0);
}
tls_dane_digest_init(client_ctx, fpt_alg);
/*
* Presently we use TLS only with SMTP where truncation attacks are not
* possible as a result of application framing. If we ever use TLS in
* some other application protocol where truncation could be relevant,
* we'd need to disable truncation detection conditionally, or explicitly
* clear the option in that code path.
*/
off |= SSL_OP_IGNORE_UNEXPECTED_EOF;
/*
* Protocol selection is destination dependent, so we delay the protocol
* selection options to the per-session SSL object.
*/
off |= tls_bug_bits();
SSL_CTX_set_options(client_ctx, off);
/*
* Set the call-back routine for verbose logging.
*/
if (log_mask & TLS_LOG_DEBUG)
SSL_CTX_set_info_callback(client_ctx, tls_info_callback);
/*
* Load the CA public key certificates for both the client cert and for
* the verification of server certificates. As provided by OpenSSL we
* support two types of CA certificate handling: One possibility is to
* add all CA certificates to one large CAfile, the other possibility is
* a directory pointed to by CApath, containing separate files for each
* CA with softlinks named after the hash values of the certificate. The
* first alternative has the advantage that the file is opened and read
* at startup time, so that you don't have the hassle to maintain another
* copy of the CApath directory for chroot-jail.
*/
if (tls_set_ca_certificate_info(client_ctx,
props->CAfile, props->CApath) < 0) {
/* tls_set_ca_certificate_info() already logs a warning. */
SSL_CTX_free(client_ctx); /* 200411 */
return (0);
}
/*
* We do not need a client certificate, so the certificates are only
* loaded (and checked) if supplied. A clever client would handle
* multiple client certificates and decide based on the list of
* acceptable CAs, sent by the server, which certificate to submit.
* OpenSSL does however not do this and also has no call-back hooks to
* easily implement it.
*
* Load the client public key certificate and private key from file and
* check whether the cert matches the key. We can use RSA certificates
* ("cert") DSA certificates ("dcert") or ECDSA certificates ("eccert").
* All three can be made available at the same time. The CA certificates
* for all three are handled in the same setup already finished. Which
* one is used depends on the cipher negotiated (that is: the first
* cipher listed by the client which does match the server). The client
* certificate is presented after the server chooses the session cipher,
* so we will just present the right cert for the chosen cipher (if it
* uses certificates).
*/
if (tls_set_my_certificate_key_info(client_ctx,
props->chain_files,
props->cert_file,
props->key_file,
props->dcert_file,
props->dkey_file,
props->eccert_file,
props->eckey_file) < 0) {
/* tls_set_my_certificate_key_info() already logs a warning. */
SSL_CTX_free(client_ctx); /* 200411 */
return (0);
}
/*
* Enable support for client->server raw public keys, provided we actually
* have keys to send. They'll only be used if the server also enables
* client RPKs.
*
* XXX: When the server requests client auth, the TLS 1.2 protocol does not
* provide an unambiguous mechanism for the client to not send an RPK (as
* it can with client X.509 certs or TLS 1.3). This is why we don't just
* enable client RPK also with no keys in hand.
*
* A very unlikely scenario is that the server allows clients to not send
* keys, but only accepts keys for a set of algorithms we don't have. Then
* we still can't send a key, but have agreed to RPK. OpenSSL will attempt
* to send an empty RPK even with TLS 1.2 (and will accept such a message),
* but other implementations may be more strict.
*
* We could limit client RPK support to connections that support only TLS
* 1.3 and up, but that's practical only decades in the future, and the
* risk scenario is contrived and very unlikely.
*/
if (SSL_CTX_get0_certificate(client_ctx) != NULL &&
SSL_CTX_get0_privatekey(client_ctx) != NULL)
tls_enable_client_rpk(client_ctx, NULL);
/*
* With OpenSSL 1.0.2 and later the client EECDH curve list becomes
* configurable with the preferred curve negotiated via the supported
* curves extension. With OpenSSL 3.0 and TLS 1.3, the same applies
* to the FFDHE groups which become part of a unified "groups" list.
*/
tls_auto_groups(client_ctx, var_tls_eecdh_auto, var_tls_ffdhe_auto);
/*
* Finally, the setup for the server certificate checking, done "by the
* book".
*/
SSL_CTX_set_verify(client_ctx, SSL_VERIFY_NONE,
tls_verify_certificate_callback);
/*
* Initialize the session cache.
*
* Since the client does not search an internal cache, we simply disable it.
* It is only useful for expiring old sessions, but we do that in the
* tlsmgr(8).
*
* This makes SSL_CTX_remove_session() not useful for flushing broken
* sessions from the external cache, so we must delete them directly (not
* via a callback).
*/
if (tls_mgr_policy(props->cache_type, &cachable,
&scache_timeout) != TLS_MGR_STAT_OK)
scache_timeout = 0;
if (scache_timeout <= 0)
cachable = 0;
/*
* Allocate an application context, and populate with mandatory protocol
* and cipher data.
*/
app_ctx = tls_alloc_app_context(client_ctx, 0, log_mask);
/*
* The external session cache is implemented by the tlsmgr(8) process.
*/
if (cachable) {
app_ctx->cache_type = mystrdup(props->cache_type);
/*
* OpenSSL does not use callbacks to load sessions from a client
* cache, so we must invoke that function directly. Apparently,
* OpenSSL does not provide a way to pass session names from here to
* call-back routines that do session lookup.
*
* OpenSSL can, however, automatically save newly created sessions for
* us by callback (we create the session name in the call-back
* function).
*
* XXX gcc 2.95 can't compile #ifdef .. #endif in the expansion of
* SSL_SESS_CACHE_CLIENT | SSL_SESS_CACHE_NO_INTERNAL_STORE |
* SSL_SESS_CACHE_NO_AUTO_CLEAR.
*/
#ifndef SSL_SESS_CACHE_NO_INTERNAL_STORE
#define SSL_SESS_CACHE_NO_INTERNAL_STORE 0
#endif
SSL_CTX_set_session_cache_mode(client_ctx,
SSL_SESS_CACHE_CLIENT |
SSL_SESS_CACHE_NO_INTERNAL_STORE |
SSL_SESS_CACHE_NO_AUTO_CLEAR);
SSL_CTX_sess_set_new_cb(client_ctx, new_client_session_cb);
/*
* OpenSSL ignores timed-out sessions. We need to set the internal
* cache timeout at least as high as the external cache timeout. This
* applies even if no internal cache is used. We set the session to
* twice the cache lifetime. This way a session always lasts longer
* than its lifetime in the cache.
*/
SSL_CTX_set_timeout(client_ctx, 2 * scache_timeout);
}
return (app_ctx);
}
/*
* This is the actual startup routine for the connection. We expect that the
* buffers are flushed and the "220 Ready to start TLS" was received by us,
* so that we can immediately start the TLS handshake process.
*/
TLS_SESS_STATE *tls_client_start(const TLS_CLIENT_START_PROPS *props)
{
int sts;
int protomask;
int min_proto;
int max_proto;
const char *cipher_list;
SSL_SESSION *session = 0;
TLS_SESS_STATE *TLScontext;
TLS_APPL_STATE *app_ctx = props->ctx;
int log_mask = app_ctx->log_mask;
/*
* When certificate verification is required, log trust chain validation
* errors even when disabled by default for opportunistic sessions. For
* DANE this only applies when using trust-anchor associations.
*/
if (TLS_MUST_MATCH(props->tls_level))
log_mask |= TLS_LOG_UNTRUSTED;
if (log_mask & TLS_LOG_VERBOSE)
msg_info("setting up TLS connection to %s", props->namaddr);
/*
* First make sure we have valid protocol and cipher parameters
*
* Per-session protocol restrictions must be applied to the SSL connection,
* as restrictions in the global context cannot be cleared.
*/
protomask = tls_proto_mask_lims(props->protocols, &min_proto, &max_proto);
if (protomask == TLS_PROTOCOL_INVALID) {
/* tls_protocol_mask() logs no warning. */
msg_warn("%s: Invalid TLS protocol list \"%s\": aborting TLS session",
props->namaddr, props->protocols);
return (0);
}
/*
* Though RFC7672 set the floor at SSLv3, we really can and should
* require TLS 1.0, since e.g. we send SNI, which is a TLS 1.0 extension.
* No DANE domains have been observed to support only SSLv3.
*
* XXX: Would be nice to make that TLS 1.2 at some point. Users can choose
* to exclude TLS 1.0 and TLS 1.1 if they find they don't run into any
* problems doing that.
*/
if (TLS_DANE_BASED(props->tls_level))
protomask |= TLS_PROTOCOL_SSLv2 | TLS_PROTOCOL_SSLv3;
/*
* Allocate a new TLScontext for the new connection and get an SSL
* structure. Add the location of TLScontext to the SSL to later retrieve
* the information inside the tls_verify_certificate_callback().
*