The FreeRADIUS server $Id: a4e7f8c94e8038b7627bcf52356b7ed15955c1d7 $
Loading...
Searching...
No Matches
conf.c
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/**
18 * $Id: c55462d29c11ccc251d965b3fb0bb86af0e1beb7 $
19 *
20 * @file tls/conf.c
21 * @brief Configuration parsing for TLS servers and clients.
22 *
23 * @copyright 2026 Network RADIUS SAS (legal@networkradius.com)
24 */
25RCSID("$Id: c55462d29c11ccc251d965b3fb0bb86af0e1beb7 $")
26USES_APPLE_DEPRECATED_API /* OpenSSL API has been deprecated by Apple */
27
28#ifdef WITH_TLS
29#define LOG_PREFIX "tls"
30
31#ifdef HAVE_SYS_STAT_H
32# include <sys/stat.h>
33#endif
34#include <openssl/conf.h>
35#include <openssl/pem.h>
36
37#include <freeradius-devel/server/module.h>
38#include <freeradius-devel/server/virtual_servers.h>
39#include <freeradius-devel/util/debug.h>
40#include <freeradius-devel/util/syserror.h>
41#include <freeradius-devel/util/rand.h>
42#include <freeradius-devel/util/math.h>
43
44#include "base.h"
45#include "log.h"
46#include "strerror.h"
47#include "utils.h"
48
49static int tls_conf_parse_server_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
50static int tls_conf_parse_client_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
51static int tls_virtual_server_cf_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
52static int tls_fragment_size_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
53static int tls_padding_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
54static int tls_ticket_lifetime_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
55static int tls_chain_private_key_file_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
56
57/** Certificate formats
58 *
59 */
60static fr_table_num_sorted_t const certificate_format_table[] = {
61 { L("ASN1"), SSL_FILETYPE_ASN1 },
62 { L("DER"), SSL_FILETYPE_ASN1 }, /* Alternate name for ASN1 */
63 { L("PEM"), SSL_FILETYPE_PEM }
64};
65static size_t certificate_format_table_len = NUM_ELEMENTS(certificate_format_table);
66
67static fr_table_num_sorted_t const chain_verify_mode_table[] = {
68 { L("hard"), FR_TLS_CHAIN_VERIFY_HARD },
69 { L("none"), FR_TLS_CHAIN_VERIFY_NONE },
70 { L("soft"), FR_TLS_CHAIN_VERIFY_SOFT }
71};
72static size_t chain_verify_mode_table_len = NUM_ELEMENTS(chain_verify_mode_table);
73
74static fr_table_num_sorted_t const cache_mode_table[] = {
75 { L("auto"), FR_TLS_TICKET_AUTO },
76 { L("disabled"), FR_TLS_TICKET_DISABLED },
77 { L("stateful"), FR_TLS_TICKET_STATEFUL },
78 { L("stateless"), FR_TLS_TICKET_STATELESS }
79};
80static size_t cache_mode_table_len = NUM_ELEMENTS(cache_mode_table);
81
82static fr_table_num_sorted_t const verify_mode_table[] = {
83 { L("all"), FR_TLS_VERIFY_MODE_ALL },
84 { L("client"), FR_TLS_VERIFY_MODE_LEAF },
85 { L("client-and-issuer"), FR_TLS_VERIFY_MODE_LEAF | FR_TLS_VERIFY_MODE_ISSUER },
86 { L("disabled"), FR_TLS_VERIFY_MODE_DISABLED },
87 { L("untrusted"), FR_TLS_VERIFY_MODE_UNTRUSTED }
88};
89static size_t verify_mode_table_len = NUM_ELEMENTS(verify_mode_table);
90
91/*
92 * The client and server share ticket configurations. However, their parsers for "mode" are different,
93 * because the client just calls load / store session, and the server can call encode / decode session.
94 */
95#define TLS_TICKET_CONFIG_COMMON \
96 { FR_CONF_OFFSET_HINT_TYPE("name", FR_TYPE_STRING, fr_tls_ticket_conf_t, id_name), \
97 .dflt = "%{EAP-Type}%interpreter('server')", .quote = T_DOUBLE_QUOTED_STRING }, \
98 { FR_CONF_OFFSET("lifetime", fr_tls_ticket_conf_t, lifetime), .func = tls_ticket_lifetime_parse, .dflt = "1d" }, \
99 { FR_CONF_OFFSET_IS_SET("min_lifetime", FR_TYPE_TIME_DELTA, 0, fr_tls_ticket_conf_t, min_lifetime), \
100 .dflt = "10s" }, \
101 { FR_CONF_OFFSET("require_extended_master_secret", fr_tls_ticket_conf_t, require_extms), .dflt = "yes" }, \
102 { FR_CONF_OFFSET("require_perfect_forward_secrecy", fr_tls_ticket_conf_t, require_pfs), .dflt = "no" }, \
103 { FR_CONF_OFFSET("session_ticket_key", fr_tls_ticket_conf_t, session_ticket_key) }, \
104 { FR_CONF_V3_DEPRECATED("enable", fr_tls_ticket_conf_t, NULL) }, \
105 { FR_CONF_V3_DEPRECATED("max_entries", fr_tls_ticket_conf_t, NULL) }, \
106 { FR_CONF_V3_DEPRECATED("persist_dir", fr_tls_ticket_conf_t, NULL) },
107
108static conf_parser_t tls_server_ticket_config[] = {
109 { FR_CONF_OFFSET("mode", fr_tls_ticket_conf_t, mode),
110 .func = tls_conf_parse_server_cache_mode,
111 .uctx = &(cf_table_parse_ctx_t){
112 .table = cache_mode_table,
113 .len = &cache_mode_table_len
114 },
115 .dflt = "disabled" },
116 TLS_TICKET_CONFIG_COMMON
117
119};
120
121static conf_parser_t tls_client_ticket_config[] = {
122 { FR_CONF_OFFSET("mode", fr_tls_ticket_conf_t, mode),
123 .func = tls_conf_parse_client_cache_mode,
124 .uctx = &(cf_table_parse_ctx_t){
125 .table = cache_mode_table,
126 .len = &cache_mode_table_len
127 },
128 .dflt = "disabled" },
129 TLS_TICKET_CONFIG_COMMON
130
132};
133
134static conf_parser_t tls_chain_config[] = {
135 { FR_CONF_OFFSET("format", fr_tls_chain_conf_t, file_format),
137 .uctx = &(cf_table_parse_ctx_t){
138 .table = certificate_format_table,
139 .len = &certificate_format_table_len
140 },
141 .dflt = "pem" },
142 /*
143 * private_key_file must be the last file row. Its parse
144 * callback loads every file in the section.
145 */
146 { FR_CONF_OFFSET_FLAGS("ca_file", CONF_FLAG_FILE_READABLE | CONF_FLAG_MULTI, fr_tls_chain_conf_t, ca_files) },
147 { FR_CONF_OFFSET_FLAGS("certificate_file", CONF_FLAG_FILE_READABLE | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, certificate_file) },
148 { FR_CONF_OFFSET_FLAGS("private_key_password", CONF_FLAG_SECRET, fr_tls_chain_conf_t, password) },
149 { FR_CONF_OFFSET_FLAGS("private_key_file", CONF_FLAG_FILE_READABLE | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, private_key_file),
150 .func = tls_chain_private_key_file_parse },
151
152 { FR_CONF_OFFSET("verify_mode", fr_tls_chain_conf_t, verify_mode),
153 .func = cf_table_parse_uint8,
154 .uctx = &(cf_table_parse_ctx_t){
155 .table = chain_verify_mode_table,
156 .len = &chain_verify_mode_table_len
157 },
158 .dflt = "hard" },
159 { FR_CONF_OFFSET("include_root_ca", fr_tls_chain_conf_t, include_root_ca), .dflt = "no" },
161};
162
163static conf_parser_t tls_verify_config[] = {
164 { FR_CONF_OFFSET("mode", fr_tls_verify_conf_t, mode),
166 .uctx = &(cf_table_parse_ctx_t){
167 .table = verify_mode_table,
168 .len = &verify_mode_table_len
169 },
170 .dflt = "all" },
171 { FR_CONF_OFFSET("attribute_mode", fr_tls_verify_conf_t, attribute_mode),
172 .func = cf_table_parse_uint8,
173 .uctx = &(cf_table_parse_ctx_t){
174 .table = verify_mode_table,
175 .len = &verify_mode_table_len
176 },
177 .dflt = "client-and-issuer" },
178 { FR_CONF_OFFSET("der_decode", fr_tls_verify_conf_t, der_decode) },
180};
181
182#ifdef PSK_MAX_IDENTITY_LEN
183static conf_parser_t tls_psk_config[] = {
184 { FR_CONF_OFFSET("identity", fr_tls_psk_conf_t, identity) },
185 { FR_CONF_OFFSET_FLAGS("key", CONF_FLAG_SECRET, fr_tls_psk_conf_t, key) },
187};
188#endif
189
190conf_parser_t fr_tls_server_config[] = {
191 { FR_CONF_OFFSET_TYPE_FLAGS("virtual_server", FR_TYPE_VOID, 0, fr_tls_conf_t, virtual_server), .func = tls_virtual_server_cf_parse },
192
193 { FR_CONF_SUBSECTION_ALLOC_MULTI("chain", 0, fr_tls_conf_t, chains, tls_chain_config),
194 .subcs_type = "fr_tls_chain_conf_t", .name2 = CF_IDENT_ANY },
195
196 { FR_CONF_V3_DEPRECATED("pem_file_type", fr_tls_conf_t, NULL) },
197 { FR_CONF_V3_DEPRECATED("certificate_file", fr_tls_conf_t, NULL) },
198 { FR_CONF_V3_DEPRECATED("private_key_password", fr_tls_conf_t, NULL) },
199 { FR_CONF_V3_DEPRECATED("private_key_file", fr_tls_conf_t, NULL) },
200
201 { FR_CONF_OFFSET("verify_depth", fr_tls_conf_t, verify_depth), .dflt = "0" },
202 { FR_CONF_OFFSET_FLAGS("ca_path", CONF_FLAG_FILE_READABLE, fr_tls_conf_t, ca_path) },
203 { FR_CONF_OFFSET_FLAGS("ca_file", CONF_FLAG_FILE_READABLE, fr_tls_conf_t, ca_file) },
204
205#ifdef PSK_MAX_IDENTITY_LEN
206 { FR_CONF_OFFSET_SUBSECTION("psk", 0, fr_tls_conf_t, psk, tls_psk_config) },
207 { FR_CONF_V3_DEPRECATED("psk_identity", fr_tls_conf_t, NULL) },
208 { FR_CONF_V3_DEPRECATED("psk_hexphrase", fr_tls_conf_t, NULL) },
209 { FR_CONF_V3_DEPRECATED("psk_query", fr_tls_conf_t, NULL) },
210#endif
211 { FR_CONF_OFFSET("keylog_file", fr_tls_conf_t, keylog_file) },
212
213 { FR_CONF_OFFSET_FLAGS("dh_file", CONF_FLAG_FILE_READABLE, fr_tls_conf_t, dh_file) },
214 { FR_CONF_OFFSET("fragment_size", fr_tls_conf_t, fragment_size), .func = tls_fragment_size_parse, .dflt = "1024" },
215 { FR_CONF_OFFSET("padding", fr_tls_conf_t, padding_block_size), .func = tls_padding_parse },
216
217 { FR_CONF_OFFSET("disable_single_dh_use", fr_tls_conf_t, disable_single_dh_use) },
218
219 { FR_CONF_OFFSET("cipher_list", fr_tls_conf_t, cipher_list) },
220 { FR_CONF_OFFSET("cipher_suites", fr_tls_conf_t, cipher_suites) },
221 { FR_CONF_OFFSET("group_list", fr_tls_conf_t, group_list) },
222 { FR_CONF_OFFSET("cipher_server_preference", fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
223#ifdef SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS
224 { FR_CONF_OFFSET("allow_renegotiation", fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
225#endif
226
227#ifndef OPENSSL_NO_ECDH
228 { FR_CONF_OFFSET("ecdh_curve", fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
229#endif
230 { FR_CONF_OFFSET("tls_max_version", fr_tls_conf_t, tls_max_version) },
231
232 { FR_CONF_OFFSET("tls_min_version", fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
233
234 { FR_CONF_OFFSET("client_hello_parse", fr_tls_conf_t, client_hello_parse )},
235
236 { FR_CONF_OFFSET_SUBSECTION("session", 0, fr_tls_conf_t, cache, tls_server_ticket_config) },
237
238 { FR_CONF_OFFSET_SUBSECTION("verify", 0, fr_tls_conf_t, verify, tls_verify_config) },
239
240 { FR_CONF_OFFSET_SUBSECTION("cache", CONF_FLAG_V3_DEPRECATED, fr_tls_conf_t, cache, tls_server_ticket_config) },
241 { FR_CONF_V3_DEPRECATED("check_cert_issuer", fr_tls_conf_t, check_cert_issuer) },
242 { FR_CONF_V3_DEPRECATED("check_cert_cn", fr_tls_conf_t, check_cert_cn) },
244};
245
246conf_parser_t fr_tls_client_config[] = {
247 /*
248 * Optional. Without it a client validates the server certificate
249 * with OpenSSL alone, which is what a caller that owns its own
250 * transport wants. With it, fr_tls_session_alloc_client() runs
251 * the `verify certificate` section of the named virtual server.
252 */
253 { FR_CONF_OFFSET_TYPE_FLAGS("virtual_server", FR_TYPE_VOID, CONF_FLAG_OK_MISSING, fr_tls_conf_t, virtual_server),
254 .func = tls_virtual_server_cf_parse },
255
256 { FR_CONF_SUBSECTION_ALLOC_MULTI("chain", CONF_FLAG_OK_MISSING, fr_tls_conf_t, chains, tls_chain_config),
257 .subcs_type = "fr_tls_chain_conf_t" },
258
259 { FR_CONF_OFFSET_SUBSECTION("verify", 0, fr_tls_conf_t, verify, tls_verify_config) },
260
261 { FR_CONF_OFFSET_SUBSECTION("session", 0, fr_tls_conf_t, cache, tls_client_ticket_config) },
262
263 { FR_CONF_V3_DEPRECATED("pem_file_type", fr_tls_conf_t, NULL) },
264 { FR_CONF_V3_DEPRECATED("certificate_file", fr_tls_conf_t, NULL) },
265 { FR_CONF_V3_DEPRECATED("private_key_password", fr_tls_conf_t, NULL) },
266 { FR_CONF_V3_DEPRECATED("private_key_file", fr_tls_conf_t, NULL) },
267
268#ifdef PSK_MAX_IDENTITY_LEN
269 { FR_CONF_OFFSET_SUBSECTION("psk", 0, fr_tls_conf_t, psk, tls_psk_config) },
270 { FR_CONF_V3_DEPRECATED("psk_identity", fr_tls_conf_t, NULL) },
271 { FR_CONF_V3_DEPRECATED("psk_hexphrase", fr_tls_conf_t, NULL) },
272#endif
273
274 { FR_CONF_OFFSET("keylog_file", fr_tls_conf_t, keylog_file) },
275
276 { FR_CONF_OFFSET("verify_depth", fr_tls_conf_t, verify_depth), .dflt = "0" },
277 { FR_CONF_OFFSET_FLAGS("ca_path", CONF_FLAG_FILE_READABLE, fr_tls_conf_t, ca_path) },
278
279 { FR_CONF_OFFSET_FLAGS("ca_file", CONF_FLAG_FILE_READABLE, fr_tls_conf_t, ca_file) },
280 { FR_CONF_OFFSET("dh_file", fr_tls_conf_t, dh_file) },
281 { FR_CONF_OFFSET("random_file", fr_tls_conf_t, random_file) },
282 { FR_CONF_OFFSET("fragment_size", fr_tls_conf_t, fragment_size), .func = tls_fragment_size_parse, .dflt = "1024" },
283
284 { FR_CONF_OFFSET("cipher_list", fr_tls_conf_t, cipher_list) },
285 { FR_CONF_OFFSET("cipher_suites", fr_tls_conf_t, cipher_suites) },
286
287#ifndef OPENSSL_NO_ECDH
288 { FR_CONF_OFFSET("ecdh_curve", fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
289#endif
290
291 { FR_CONF_OFFSET("tls_max_version", fr_tls_conf_t, tls_max_version) },
292
293 { FR_CONF_OFFSET("tls_min_version", fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
294
295 { FR_CONF_OFFSET_SUBSECTION("cache", CONF_FLAG_V3_DEPRECATED, fr_tls_conf_t, cache, tls_client_ticket_config) },
296 { FR_CONF_V3_DEPRECATED("check_cert_issuer", fr_tls_conf_t, check_cert_issuer) },
297 { FR_CONF_V3_DEPRECATED("check_cert_cn", fr_tls_conf_t, check_cert_cn) },
299};
300
301static int tls_virtual_server_cf_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
302{
303 fr_tls_conf_t *conf = talloc_get_type_abort(parent, fr_tls_conf_t);
304 virtual_server_t const *vs = NULL;
305
306 if (virtual_server_cf_parse(ctx, &vs, parent, ci, rule) < 0) return -1;
307
308 if (!vs) return 0;
309
310 /*
311 * `out` points to conf->virtual_server
312 */
313 *((CONF_SECTION const **)out) = virtual_server_cs(vs);
314
315#define EXISTS(_x, _y) (cf_section_find(conf->virtual_server, _x, _y) != NULL)
316
317 conf->verify_certificate = EXISTS("verify", "certificate");
318 conf->new_session = EXISTS("new", "session");
319 conf->establish_session = EXISTS("establish", "session");
320 conf->fail_session = EXISTS("fail", "session");
321 conf->encode_session = EXISTS("encode", "session");
322 conf->decode_session = EXISTS("decode", "session");
323 conf->load_session = EXISTS("load", "session");
324 conf->store_session = EXISTS("store", "session");
325 conf->clear_session = EXISTS("clear", "session");
326#ifdef PSK_MAX_IDENTITY_LEN
327 conf->load_psk = EXISTS("load", "psk");
328#else
329 if (cf_section_find(conf->virtual_server, "load", "psk")) {
330 cf_log_err(ci, "Specified virtual_server has a \"load psk { ... }\" section, "
331 "but OpenSSL was built without PSK support");
332 return -1;
333 }
334#endif
335 return 0;
336}
337
338/** Generate the session ticket key if the mode needs one, and write out the mode
339 *
340 */
341static int tls_conf_cache_mode_set(fr_tls_conf_t *conf, int cache_mode, void *out)
342{
343 /*
344 * Generate random, ephemeral, session-ticket keys.
345 */
346 if (cache_mode & FR_TLS_TICKET_STATELESS) {
347 /*
348 * Fill the key with randomness if one wasn't specified by the user.
349 */
350 if (!conf->cache.session_ticket_key) {
351 MEM(conf->cache.session_ticket_key = talloc_array(conf, uint8_t, 256));
352 fr_rand_buffer(UNCONST(uint8_t *, conf->cache.session_ticket_key),
353 talloc_array_length(conf->cache.session_ticket_key));
354 }
355 }
356
357 *((int *)out) = cache_mode;
358
359 return 0;
360}
361
362#define CHECK_MODE(_x) \
363 do { \
364 if (!conf->_x ## _session) { \
365 cf_log_err(ci, "Virtual server %s must contain a \"" STRINGIFY(_x) " session { ... }\" section when session.mode = \"%s\"", cf_section_name2(conf->virtual_server), fr_table_str_by_value(cache_mode_table, cache_mode, "disabled")); \
366 return -1; \
367 } \
368 } while (0)
369
370/** Parse cache mode for a TLS server
371 *
372 * Stateless tickets need `encode session` and `decode session`. @todo - arguable also `clear session` for
373 * "oopsies" like TTLS.
374 *
375 * Stateful tickets need `load session`, `store session`, and `clear session`.
376 */
377static int tls_conf_parse_server_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
378{
379 fr_tls_conf_t *conf = talloc_get_type_abort((uint8_t *)parent - offsetof(fr_tls_conf_t, cache), fr_tls_conf_t);
380 int cache_mode;
381
382 if (cf_table_parse_int(ctx, &cache_mode, parent, ci, rule) < 0) return -1;
383
384 conf->cache.mode_is_auto = (cache_mode == FR_TLS_TICKET_AUTO);
385
386 /*
387 * Modes other than "disabled" (0) require a virtual server.
388 */
389 if (cache_mode && !conf->virtual_server) {
390 cf_log_err(ci, "A virtual_server must be set when session.mode = \"%s\"",
391 fr_table_str_by_value(cache_mode_table, cache_mode, "disabled"));
392 return -1;
393 }
394
395 /*
396 * Ensure our virtual server contains the
397 * correct sections for the specified
398 * cache mode.
399 */
400 switch (cache_mode) {
401 case FR_TLS_TICKET_DISABLED:
402 break;
403
404 case FR_TLS_TICKET_STATELESS:
405 CHECK_MODE(encode);
406 CHECK_MODE(decode);
407 break;
408
409 case FR_TLS_TICKET_STATEFUL:
410 check_stateful:
411 CHECK_MODE(load);
412 CHECK_MODE(store);
413 CHECK_MODE(clear);
414 break;
415
416 case FR_TLS_TICKET_AUTO:
417 if (!conf->encode_session) {
418 cf_log_warn(ci, "Virtual server %s is missing an \"encode session { ... }\" section. "
419 "Rewriting session.mode = \"auto\" to \"stateful\"",
420 cf_section_name2(conf->virtual_server));
421 cache_mode = FR_TLS_TICKET_STATEFUL;
422 goto check_stateful;
423 }
424
425 if (!conf->decode_session) {
426 cf_log_warn(ci, "Virtual server %s is missing a \"decode session { ... }\" section. "
427 "Rewriting session.mode = \"auto\" to \"stateful\"",
428 cf_section_name2(conf->virtual_server));
429 cache_mode = FR_TLS_TICKET_STATEFUL;
430 goto check_stateful;
431 }
432
433 if (!conf->load_session) {
434 cf_log_warn(ci, "Virtual server %s is missing a \"load session { ... }\" section. "
435 "Rewriting session.mode = \"auto\" to \"stateless\"",
436 cf_section_name2(conf->virtual_server));
437 cache_mode = FR_TLS_TICKET_STATELESS;
438 break;
439 }
440
441 if (!conf->store_session) {
442 cf_log_warn(ci, "Virtual server %s is missing a \"store session { ... }\" section. "
443 "Rewriting session.mode = \"auto\" to \"stateless\"",
444 cf_section_name2(conf->virtual_server));
445 cache_mode = FR_TLS_TICKET_STATELESS;
446 break;
447 }
448
449 if (!conf->clear_session) {
450 cf_log_warn(ci, "Virtual server %s is missing a \"clear session { ... }\" section. "
451 "Rewriting session.mode = \"auto\" to \"stateless\"",
452 cf_section_name2(conf->virtual_server));
453 cache_mode = FR_TLS_TICKET_STATELESS;
454 break;
455 }
456 break;
457 }
458
459 return tls_conf_cache_mode_set(conf, cache_mode, out);
460}
461
462/** Parse "mode" for a TLS client
463 *
464 * A client tells a server whether it supports stateful or stateless session tickets, because a server
465 * responds slightly differently to each one. Yay TLS magic.
466 *
467 * However, the client mashes both types of tickets into `load session` and `store session`, because it can't
468 * do anything else with them.
469 */
470static int tls_conf_parse_client_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
471{
472 fr_tls_conf_t *conf = talloc_get_type_abort((uint8_t *)parent - offsetof(fr_tls_conf_t, cache), fr_tls_conf_t);
473 int cache_mode;
474
475 if (cf_table_parse_int(ctx, &cache_mode, parent, ci, rule) < 0) return -1;
476
477 /*
478 * Modes other than "disabled" (0) require a virtual server.
479 */
480 if (cache_mode && !conf->virtual_server) {
481 cf_log_err(ci, "A virtual_server must be set when session.mode = \"%s\"",
482 fr_table_str_by_value(cache_mode_table, cache_mode, "disabled"));
483 return -1;
484 }
485
486 switch (cache_mode) {
487 case FR_TLS_TICKET_DISABLED:
488 break;
489
490 case FR_TLS_TICKET_STATELESS:
491 case FR_TLS_TICKET_AUTO:
492 cf_log_warn(ci, "A TLS client always uses \"store session { ... }\" and "
493 "\"load session { ... }\" to store tickets. Rewriting session.mode = \"%s\" to \"stateful\"",
494 (cache_mode == FR_TLS_TICKET_AUTO) ? "auto" : "stateless");
495 cache_mode = FR_TLS_TICKET_STATEFUL;
497
498 case FR_TLS_TICKET_STATEFUL:
499 CHECK_MODE(load);
500 CHECK_MODE(store);
501 CHECK_MODE(clear);
502 break;
503 }
504
505 return tls_conf_cache_mode_set(conf, cache_mode, out);
506}
507
508/** Keep `fragment_size` between 100 and the TLS record limit
509 *
510 * A TLS record holds at most SSL3_RT_MAX_PLAIN_LENGTH bytes, so a larger
511 * fragment size gains nothing. The EAP RFCs ask for fragments of at least
512 * 1020 bytes, but the server accepts down to 100.
513 */
514static int tls_fragment_size_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
515{
516 uint32_t *fragment_size = out;
517
518 if (cf_pair_parse_value(ctx, out, parent, ci, rule) < 0) return -1;
519
520 if (*fragment_size < 100) {
521 cf_log_warn(ci, "Ignoring \"fragment_size = %u\", forcing to \"fragment_size = 100\"", *fragment_size);
522 *fragment_size = 100;
523 }
524 if (*fragment_size > SSL3_RT_MAX_PLAIN_LENGTH) {
525 cf_log_warn(ci, "Ignoring \"fragment_size = %u\", forcing to \"fragment_size = %u\"",
526 *fragment_size, (unsigned int)SSL3_RT_MAX_PLAIN_LENGTH);
527 *fragment_size = SSL3_RT_MAX_PLAIN_LENGTH;
528 }
529
530 return 0;
531}
532
533/** Parse padding, and clamp / round it.
534 *
535 * - 0 means "no padding"
536 * - >256 is clamped to 256
537 * - we round to multiples of 16.
538 *
539 * We mangle the padding before writing it to the configuration,
540 * because we can't write to the configuration afterwards, due to
541 * mprotect().
542 */
543static int tls_padding_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
544{
545 uint32_t *padding = out;
546
547 if (cf_pair_parse_value(ctx, out, parent, ci, rule) < 0) return -1;
548
549 if (!*padding) return 0;
550
551 if (*padding > FR_TLS_MAX_BLOCK_PADDING) {
552 cf_log_warn(ci, "Ignoring \"padding = %u\", forcing to \"padding = %u\"",
553 *padding, (unsigned int) FR_TLS_MAX_BLOCK_PADDING);
554 *padding = FR_TLS_MAX_BLOCK_PADDING;
555 }
556
557 *padding = ROUND_UP_POW2(*padding, FR_TLS_BLOCK_PADDING_MULTIPLE);
558
559 return 0;
560}
561
562/** Keep `session.lifetime` at or below #FR_TLS_MAX_SESSION_LIFETIME
563 *
564 */
565static int tls_ticket_lifetime_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
566{
567 fr_time_delta_t *lifetime = out;
568 fr_time_delta_t const max = fr_time_delta_from_sec(FR_TLS_MAX_SESSION_LIFETIME);
569
570 if (cf_pair_parse_value(ctx, out, parent, ci, rule) < 0) return -1;
571
572 if (fr_time_delta_gt(*lifetime, max)) {
573 cf_log_warn(ci, "Ignoring \"lifetime = %pV\", forcing to \"lifetime = %pV\"",
575 *lifetime = max;
576 }
577
578 return 0;
579}
580
581#ifdef __APPLE__
582/*
583 * Setting private_key_password to this marker reads the
584 * password from certadmin instead.
585 */
586static char const *special_string = "Apple:UsecertAdmin";
587
588/** Read the private key password from certadmin
589 *
590 * @param[in,out] chain whose password is replaced when set to the marker.
591 * @param[in] ci for error messages.
592 * @return
593 * - 0 on success, or if the password is not the marker.
594 * - -1 if certadmin failed.
595 */
596static int tls_chain_password_certadmin(fr_tls_chain_conf_t *chain, CONF_ITEM *ci)
597{
598 char cmd[256];
599 char *password, *buf;
600 long const max_password_len = 128;
601 FILE *cmd_pipe;
602
603 if (!chain->password) return 0;
604 if (strncmp(chain->password, special_string, strlen(special_string)) != 0) return 0;
605
606 snprintf(cmd, sizeof(cmd) - 1, "/usr/sbin/certadmin --get-private-key-passphrase \"%s\"",
607 chain->private_key_file);
608
609 DEBUG2("Getting private key passphrase using command \"%s\"", cmd);
610
611 cmd_pipe = popen(cmd, "r");
612 if (!cmd_pipe) {
613 cf_log_err(ci, "%s command failed: Unable to get private_key_password", cmd);
614 cf_log_err(ci, "Error reading private_key_file %s", chain->private_key_file);
615 return -1;
616 }
617
618 MEM(password = talloc_array(chain, char, max_password_len));
619
620 buf = fgets(password, max_password_len, cmd_pipe);
621 if (!buf || ferror(cmd_pipe)) {
622 pclose(cmd_pipe);
623 talloc_free(password);
624 cf_log_err(ci, "%s command failed: Unable to get private_key_password", cmd);
625 cf_log_err(ci, "Error reading private_key_file %s", chain->private_key_file);
626 return -1;
627 }
628 pclose(cmd_pipe);
629
630 /* Get rid of newline at end of password. */
631 for (buf = password; buf < (password + max_password_len); buf++) {
632 if ((unsigned char)*buf < ' ') {
633 *buf = '\0';
634 goto found;
635 }
636 }
637
638 talloc_free(password);
639 cf_log_err(ci, "%s command failed: Unable to get private_key_password", cmd);
640 cf_log_err(ci, "Error reading private_key_file %s - password is too long", chain->private_key_file);
641 return -1;
642
643found:
644 DEBUG3("Password from command = \"%s\"", password);
645 talloc_const_free(chain->password);
646 chain->password = password;
647
648 return 0;
649}
650#endif
651
652/** Free the OpenSSL objects that a chain section holds
653 */
654static int _tls_chain_conf_free(fr_tls_chain_conf_t *chain)
655{
656 if (chain->leaf) X509_free(chain->leaf);
657DIAG_OFF_OPTIONAL(used-but-marked-unused) /* fix spurious warnings for sk macros */
658 if (chain->extra) sk_X509_pop_free(chain->extra, X509_free);
659DIAG_ON_OPTIONAL(used-but-marked-unused)
660 if (chain->private_key) EVP_PKEY_free(chain->private_key);
661
662 return 0;
663}
664
665/** Read one certificate from a file
666 *
667 * @param[in] ci for error messages.
668 * @param[in] fp positioned at the next certificate.
669 * @param[in] format SSL_FILETYPE_PEM or SSL_FILETYPE_ASN1.
670 * @param[in] aux read the PEM auxiliary trust data, as OpenSSL does for the leaf.
671 * @return
672 * - The certificate.
673 * - NULL at the end of a PEM file, with the error queue empty.
674 * - NULL on error, with the error left on the queue.
675 */
676static X509 *tls_chain_cert_read(CONF_ITEM *ci, FILE *fp, int format, bool aux)
677{
678 X509 *cert;
679
680 switch (format) {
681 case SSL_FILETYPE_PEM:
682 cert = aux ? PEM_read_X509_AUX(fp, NULL, NULL, NULL) : PEM_read_X509(fp, NULL, NULL, NULL);
683 if (!cert) {
684 unsigned long err = ERR_peek_last_error();
685
686 /*
687 * OpenSSL reports the end of a file by writing
688 * PEM_R_NO_START_LINE to the thread local buffer.
689 */
690DIAG_OFF_OPTIONAL(used-but-marked-unused) /* fix spurious warnings for ERR_GET macros */
691 if ((ERR_GET_LIB(err) == ERR_LIB_PEM) && (ERR_GET_REASON(err) == PEM_R_NO_START_LINE)) {
692 ERR_clear_error();
693 }
694DIAG_ON_OPTIONAL(used-but-marked-unused)
695 }
696 return cert;
697
698 case SSL_FILETYPE_ASN1:
699 return d2i_X509_fp(fp, NULL);
700
701 default:
702 cf_log_err(ci, "Unknown certificate format %d", format);
703 return NULL;
704 }
705}
706
707/** Load the certificates and the private key of a `chain { ... }` section
708 *
709 * Reads certificate files in this order:
710 *
711 * 1. The leaf, then the remaining certificates, from certificate_file.
712 * 2. One certificate from each ca_file.
713 * 3. The private key from private_key_file.
714 *
715 * This callback stores the loaded objects in leaf, extra, and private_key,
716 * and records the earliest notAfter in valid_until.
717 */
718static int tls_chain_private_key_file_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
719{
720 fr_tls_chain_conf_t *chain = talloc_get_type_abort(parent, fr_tls_chain_conf_t);
721 FILE *fp;
722 X509 *cert;
723 size_t i, ca_cnt;
724 int n;
725
726 if (cf_pair_parse_value(ctx, out, parent, ci, rule) < 0) return -1;
727
728#ifdef __APPLE__
729 if (tls_chain_password_certadmin(chain, ci) < 0) return -1;
730#endif
731
732 talloc_set_destructor(chain, _tls_chain_conf_free);
733
734 /*
735 * The leaf comes first, then the rest of the chain.
736 */
737 fp = fopen(chain->certificate_file, "r");
738 if (!fp) {
739 cf_log_err(ci, "Failed opening certificate_file \"%s\": %s", chain->certificate_file, fr_syserror(errno));
740 return -1;
741 }
742
743 chain->leaf = tls_chain_cert_read(ci, fp, chain->file_format, true);
744 if (!chain->leaf) {
745 fr_tls_strerror_printf("No certificate found");
746 cf_log_perr(ci, "Failed reading certificate_file \"%s\"", chain->certificate_file);
747 fclose(fp);
748 return -1;
749 }
750
751 MEM(chain->extra = sk_X509_new_null());
752 while ((cert = tls_chain_cert_read(ci, fp, chain->file_format, false))) {
753 if (chain->file_format != SSL_FILETYPE_PEM) {
754 X509_free(cert);
755 break; /* A DER file holds exactly one certificate */
756 }
757DIAG_OFF_OPTIONAL(used-but-marked-unused) /* fix spurious warnings for sk macros */
758 MEM(sk_X509_push(chain->extra, cert) > 0);
759DIAG_ON_OPTIONAL(used-but-marked-unused)
760 }
761 fclose(fp);
762 if (ERR_peek_error()) {
763 fr_tls_strerror_printf(NULL);
764 cf_log_perr(ci, "Failed reading certificate_file \"%s\"", chain->certificate_file);
765 return -1;
766 }
767
768 /*
769 * One certificate per ca_file.
770 */
771 ca_cnt = chain->ca_files ? talloc_array_length(chain->ca_files) : 0;
772 for (i = 0; i < ca_cnt; i++) {
773 fp = fopen(chain->ca_files[i], "r");
774 if (!fp) {
775 cf_log_err(ci, "Failed opening ca_file \"%s\": %s", chain->ca_files[i], fr_syserror(errno));
776 return -1;
777 }
778 cert = tls_chain_cert_read(ci, fp, chain->file_format, false);
779 fclose(fp);
780 if (!cert) {
781 fr_tls_strerror_printf("No certificate found");
782 cf_log_perr(ci, "Failed reading ca_file \"%s\"", chain->ca_files[i]);
783 return -1;
784 }
785DIAG_OFF_OPTIONAL(used-but-marked-unused) /* fix spurious warnings for sk macros */
786 MEM(sk_X509_push(chain->extra, cert) > 0);
787DIAG_ON_OPTIONAL(used-but-marked-unused)
788 }
789
790 /*
791 * The password callback stops OpenSSL prompting on stdin
792 * when the key is encrypted and no password is set.
793 */
794 fp = fopen(chain->private_key_file, "r");
795 if (!fp) {
796 cf_log_err(ci, "Failed opening private_key_file \"%s\": %s", chain->private_key_file, fr_syserror(errno));
797 return -1;
798 }
799 switch (chain->file_format) {
800 case SSL_FILETYPE_PEM:
801 chain->private_key = PEM_read_PrivateKey(fp, NULL, fr_tls_session_password_cb,
802 UNCONST(char *, chain->password));
803 break;
804
805 case SSL_FILETYPE_ASN1:
806 chain->private_key = d2i_PrivateKey_fp(fp, NULL);
807 break;
808
809 default:
810 fr_assert(0);
811 break;
812 }
813 fclose(fp);
814 if (!chain->private_key) {
815 fr_tls_strerror_printf(NULL);
816 cf_log_perr(ci, "Failed reading private_key_file \"%s\"", chain->private_key_file);
817 return -1;
818 }
819
820 if (X509_check_private_key(chain->leaf, chain->private_key) != 1) {
821 fr_tls_strerror_printf(NULL);
822 cf_log_perr(ci, "Private key does not match the certificate public key");
823 return -1;
824 }
825
826 /*
827 * Record the earliest notAfter.
828 */
829 chain->valid_until = fr_unix_time_wrap(0);
830DIAG_OFF_OPTIONAL(used-but-marked-unused) /* fix spurious warnings for sk macros */
831 for (n = -1; n < sk_X509_num(chain->extra); n++) {
832 time_t not_after;
833
834 cert = (n < 0) ? chain->leaf : sk_X509_value(chain->extra, n);
835 if (fr_tls_utils_asn1time_to_epoch(&not_after, X509_get0_notAfter(cert)) < 0) {
836 cf_log_perr(ci, "Failed parsing notAfter time of certificate %d in the chain", n + 2);
837 return -1;
838 }
839 if (!fr_unix_time_ispos(chain->valid_until) ||
840 fr_unix_time_gt(chain->valid_until, fr_unix_time_from_time(not_after))) {
841 chain->valid_until = fr_unix_time_from_time(not_after);
842 }
843 }
844DIAG_ON_OPTIONAL(used-but-marked-unused)
845
846 cf_log_debug(ci, "Certificate chain valid until %pV", fr_box_date(chain->valid_until));
847
848 return 0;
849}
850#endif /* WITH_TLS */
int n
Definition acutest.h:642
#define store(_store, _var)
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:203
#define USES_APPLE_DEPRECATED_API
Definition build.h:590
#define RCSID(id)
Definition build.h:603
#define DIAG_OFF_OPTIONAL(_x)
Definition build.h:577
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:245
#define FALL_THROUGH
clang 10 doesn't recognised the FALL-THROUGH comment anymore
Definition build.h:422
#define NUM_ELEMENTS(_t)
Definition build.h:437
#define DIAG_ON_OPTIONAL(_x)
Definition build.h:578
int cf_pair_parse_value(TALLOC_CTX *ctx, void *out, UNUSED void *base, CONF_ITEM *ci, conf_parser_t const *rule)
Parses a CONF_PAIR into a C data type.
Definition cf_parse.c:252
#define CONF_PARSER_TERMINATOR
Definition cf_parse.h:722
cf_parse_t func
Override default parsing behaviour for the specified type with a custom parsing function.
Definition cf_parse.h:666
#define FR_CONF_V3_DEPRECATED(_name, _struct, _field)
conf_parser_t entry which raises an error if a deprecated v3 item is found
Definition cf_parse.h:446
#define FR_CONF_OFFSET(_name, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
Definition cf_parse.h:280
#define FR_CONF_SUBSECTION_ALLOC_MULTI(_name, _flags, _struct, _field, _subcs)
conf_parser_t which allocates one struct for each instance of a subsection
Definition cf_parse.h:403
int cf_table_parse_int(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
@ CONF_FLAG_REQUIRED
Error out if no matching CONF_PAIR is found, and no dflt value is set.
Definition cf_parse.h:466
@ CONF_FLAG_MULTI
CONF_PAIR can have multiple copies.
Definition cf_parse.h:483
@ CONF_FLAG_V3_DEPRECATED
If a matching CONF_PAIR is found, error out with a deprecated message.
Definition cf_parse.h:464
@ CONF_FLAG_SECRET
Only print value if debug level >= 3.
Definition cf_parse.h:470
@ CONF_FLAG_FILE_READABLE
File matching value must exist, and must be readable.
Definition cf_parse.h:472
@ CONF_FLAG_OK_MISSING
OK if it's missing.
Definition cf_parse.h:491
@ CONF_FLAG_FILE_EXISTS
File matching value must exist.
Definition cf_parse.h:478
int cf_table_parse_uint8(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
#define FR_CONF_OFFSET_FLAGS(_name, _flags, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
Definition cf_parse.h:268
#define FR_CONF_OFFSET_SUBSECTION(_name, _flags, _struct, _field, _subcs)
conf_parser_t which populates a sub-struct using a CONF_SECTION
Definition cf_parse.h:309
#define FR_CONF_OFFSET_TYPE_FLAGS(_name, _type, _flags, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
Definition cf_parse.h:238
Defines a CONF_PAIR to C data type mapping.
Definition cf_parse.h:649
Common header for all CONF_* types.
Definition cf_priv.h:54
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:106
char const * cf_section_name2(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1405
CONF_SECTION * cf_section_find(CONF_SECTION const *cs, char const *name1, char const *name2)
Find a CONF_SECTION with name1 and optionally name2.
Definition cf_util.c:1247
#define cf_log_err(_cf, _fmt,...)
Definition cf_util.h:340
#define cf_log_perr(_cf, _fmt,...)
Definition cf_util.h:347
#define cf_log_warn(_cf, _fmt,...)
Definition cf_util.h:341
#define cf_log_debug(_cf, _fmt,...)
Definition cf_util.h:343
#define CF_IDENT_ANY
Definition cf_util.h:80
#define MEM(x)
Definition debug.h:38
talloc_free(hp)
#define DEBUG3(_fmt,...)
Definition log.h:271
#define ROUND_UP_POW2(_num, _mul)
Round up - Only works if _mul is a power of 2 but avoids division.
Definition math.h:205
@ FR_TYPE_VOID
User data.
unsigned int uint32_t
unsigned char uint8_t
static size_t used
static fr_radius_decode_fail_t decode(TALLOC_CTX *ctx, fr_pair_list_t *reply, uint8_t *response_code, bio_handle_t *h, request_t *request, bio_request_t *u, uint8_t const request_authenticator[static RADIUS_AUTH_VECTOR_LENGTH], uint8_t *data, size_t data_len)
Decode response packet data, extracting relevant information and validating the packet.
Definition bio.c:1771
static int encode(bio_handle_t *h, request_t *request, bio_request_t *u, uint8_t id)
Definition bio.c:1842
#define fr_assert(_expr)
Definition rad_assert.h:37
#define DEBUG2(fmt,...)
static rs_t * conf
Definition radsniff.c:52
void fr_rand_buffer(void *start, size_t length)
Definition rand.c:148
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
Definition syserror.c:243
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:804
An element in a lexicographically sorted array of name to num mappings.
Definition table.h:49
static int talloc_const_free(void const *ptr)
Free const'd memory.
Definition talloc.h:289
#define fr_unix_time_ispos(_a)
Definition time.h:372
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:599
#define fr_unix_time_gt(_a, _b)
Definition time.h:365
#define fr_unix_time_wrap(_time)
Definition time.h:160
static fr_unix_time_t fr_unix_time_from_time(time_t time)
Convert a time_t into out internal fr_unix_time_t.
Definition time.h:545
#define fr_time_delta_gt(_a, _b)
Definition time.h:283
A time delta, a difference in time measured in nanoseconds.
Definition time.h:80
static fr_slen_t parent
Definition pair.h:864
int fr_tls_utils_asn1time_to_epoch(time_t *out, ASN1_TIME const *asn1)
Convert OpenSSL's ASN1_TIME to an epoch time.
Definition utils.c:128
static fr_sbuff_err_t char size_t fr_sbuff_t size_t max
Definition value.h:1061
static fr_sbuff_err_t char ** out
Definition value.h:1061
#define fr_box_time_delta(_val)
Definition value.h:397
#define fr_box_date(_val)
Definition value.h:378
CONF_SECTION * virtual_server_cs(virtual_server_t const *vs)
Return the configuration section for a virtual server.
int virtual_server_cf_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
Wrapper for the config parser to allow pass1 resolution of virtual servers.