xref: /dragonfly/crypto/libressl/tls/tls_config.c (revision 27ea30e3) 
1 /* $OpenBSD: tls_config.c,v 1.58 2020/01/20 08:39:21 jsing Exp $ */
2 /*
3  * Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include <sys/stat.h>
19 
20 #include <ctype.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <pthread.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 
27 #include <tls.h>
28 
29 #include "tls_internal.h"
30 
31 static const char default_ca_file[] = TLS_DEFAULT_CA_FILE;
32 
33 const char *
34 tls_default_ca_cert_file(void)
35 {
36 	return default_ca_file;
37 }
38 
39 int
40 tls_config_load_file(struct tls_error *error, const char *filetype,
41     const char *filename, char **buf, size_t *len)
42 {
43 	struct stat st;
44 	int fd = -1;
45 	ssize_t n;
46 
47 	free(*buf);
48 	*buf = NULL;
49 	*len = 0;
50 
51 	if ((fd = open(filename, O_RDONLY)) == -1) {
52 		tls_error_set(error, "failed to open %s file '%s'",
53 		    filetype, filename);
54 		goto err;
55 	}
56 	if (fstat(fd, &st) != 0) {
57 		tls_error_set(error, "failed to stat %s file '%s'",
58 		    filetype, filename);
59 		goto err;
60 	}
61 	if (st.st_size < 0)
62 		goto err;
63 	*len = (size_t)st.st_size;
64 	if ((*buf = malloc(*len)) == NULL) {
65 		tls_error_set(error, "failed to allocate buffer for "
66 		    "%s file", filetype);
67 		goto err;
68 	}
69 	n = read(fd, *buf, *len);
70 	if (n < 0 || (size_t)n != *len) {
71 		tls_error_set(error, "failed to read %s file '%s'",
72 		    filetype, filename);
73 		goto err;
74 	}
75 	close(fd);
76 	return 0;
77 
78  err:
79 	if (fd != -1)
80 		close(fd);
81 	freezero(*buf, *len);
82 	*buf = NULL;
83 	*len = 0;
84 
85 	return -1;
86 }
87 
88 struct tls_config *
89 tls_config_new_internal(void)
90 {
91 	struct tls_config *config;
92 	unsigned char sid[TLS_MAX_SESSION_ID_LENGTH];
93 
94 	if ((config = calloc(1, sizeof(*config))) == NULL)
95 		return (NULL);
96 
97 	if (pthread_mutex_init(&config->mutex, NULL) != 0)
98 		goto err;
99 
100 	config->refcount = 1;
101 	config->session_fd = -1;
102 
103 	if ((config->keypair = tls_keypair_new()) == NULL)
104 		goto err;
105 
106 	/*
107 	 * Default configuration.
108 	 */
109 	if (tls_config_set_dheparams(config, "none") != 0)
110 		goto err;
111 	if (tls_config_set_ecdhecurves(config, "default") != 0)
112 		goto err;
113 	if (tls_config_set_ciphers(config, "secure") != 0)
114 		goto err;
115 
116 	if (tls_config_set_protocols(config, TLS_PROTOCOLS_DEFAULT) != 0)
117 		goto err;
118 	if (tls_config_set_verify_depth(config, 6) != 0)
119 		goto err;
120 
121 	/*
122 	 * Set session ID context to a random value.  For the simple case
123 	 * of a single process server this is good enough. For multiprocess
124 	 * servers the session ID needs to be set by the caller.
125 	 */
126 	arc4random_buf(sid, sizeof(sid));
127 	if (tls_config_set_session_id(config, sid, sizeof(sid)) != 0)
128 		goto err;
129 	config->ticket_keyrev = arc4random();
130 	config->ticket_autorekey = 1;
131 
132 	tls_config_prefer_ciphers_server(config);
133 
134 	tls_config_verify(config);
135 
136 	return (config);
137 
138  err:
139 	tls_config_free(config);
140 	return (NULL);
141 }
142 
143 struct tls_config *
144 tls_config_new(void)
145 {
146 	if (tls_init() == -1)
147 		return (NULL);
148 
149 	return tls_config_new_internal();
150 }
151 
152 void
153 tls_config_free(struct tls_config *config)
154 {
155 	struct tls_keypair *kp, *nkp;
156 	int refcount;
157 
158 	if (config == NULL)
159 		return;
160 
161 	pthread_mutex_lock(&config->mutex);
162 	refcount = --config->refcount;
163 	pthread_mutex_unlock(&config->mutex);
164 
165 	if (refcount > 0)
166 		return;
167 
168 	for (kp = config->keypair; kp != NULL; kp = nkp) {
169 		nkp = kp->next;
170 		tls_keypair_free(kp);
171 	}
172 
173 	free(config->error.msg);
174 
175 	free(config->alpn);
176 	free((char *)config->ca_mem);
177 	free((char *)config->ca_path);
178 	free((char *)config->ciphers);
179 	free((char *)config->crl_mem);
180 	free(config->ecdhecurves);
181 
182 	free(config);
183 }
184 
185 static void
186 tls_config_keypair_add(struct tls_config *config, struct tls_keypair *keypair)
187 {
188 	struct tls_keypair *kp;
189 
190 	kp = config->keypair;
191 	while (kp->next != NULL)
192 		kp = kp->next;
193 
194 	kp->next = keypair;
195 }
196 
197 const char *
198 tls_config_error(struct tls_config *config)
199 {
200 	return config->error.msg;
201 }
202 
203 void
204 tls_config_clear_keys(struct tls_config *config)
205 {
206 	struct tls_keypair *kp;
207 
208 	for (kp = config->keypair; kp != NULL; kp = kp->next)
209 		tls_keypair_clear_key(kp);
210 }
211 
212 int
213 tls_config_parse_protocols(uint32_t *protocols, const char *protostr)
214 {
215 	uint32_t proto, protos = 0;
216 	char *s, *p, *q;
217 	int negate;
218 
219 	if (protostr == NULL) {
220 		*protocols = TLS_PROTOCOLS_DEFAULT;
221 		return (0);
222 	}
223 
224 	if ((s = strdup(protostr)) == NULL)
225 		return (-1);
226 
227 	q = s;
228 	while ((p = strsep(&q, ",:")) != NULL) {
229 		while (*p == ' ' || *p == '\t')
230 			p++;
231 
232 		negate = 0;
233 		if (*p == '!') {
234 			negate = 1;
235 			p++;
236 		}
237 
238 		if (negate && protos == 0)
239 			protos = TLS_PROTOCOLS_ALL;
240 
241 		proto = 0;
242 		if (strcasecmp(p, "all") == 0 ||
243 		    strcasecmp(p, "legacy") == 0)
244 			proto = TLS_PROTOCOLS_ALL;
245 		else if (strcasecmp(p, "default") == 0 ||
246 		    strcasecmp(p, "secure") == 0)
247 			proto = TLS_PROTOCOLS_DEFAULT;
248 		if (strcasecmp(p, "tlsv1") == 0)
249 			proto = TLS_PROTOCOL_TLSv1;
250 		else if (strcasecmp(p, "tlsv1.0") == 0)
251 			proto = TLS_PROTOCOL_TLSv1_0;
252 		else if (strcasecmp(p, "tlsv1.1") == 0)
253 			proto = TLS_PROTOCOL_TLSv1_1;
254 		else if (strcasecmp(p, "tlsv1.2") == 0)
255 			proto = TLS_PROTOCOL_TLSv1_2;
256 		else if (strcasecmp(p, "tlsv1.3") == 0)
257 			proto = TLS_PROTOCOL_TLSv1_3;
258 
259 		if (proto == 0) {
260 			free(s);
261 			return (-1);
262 		}
263 
264 		if (negate)
265 			protos &= ~proto;
266 		else
267 			protos |= proto;
268 	}
269 
270 	*protocols = protos;
271 
272 	free(s);
273 
274 	return (0);
275 }
276 
277 static int
278 tls_config_parse_alpn(struct tls_config *config, const char *alpn,
279     char **alpn_data, size_t *alpn_len)
280 {
281 	size_t buf_len, i, len;
282 	char *buf = NULL;
283 	char *s = NULL;
284 	char *p, *q;
285 
286 	free(*alpn_data);
287 	*alpn_data = NULL;
288 	*alpn_len = 0;
289 
290 	if ((buf_len = strlen(alpn) + 1) > 65535) {
291 		tls_config_set_errorx(config, "alpn too large");
292 		goto err;
293 	}
294 
295 	if ((buf = malloc(buf_len)) == NULL) {
296 		tls_config_set_errorx(config, "out of memory");
297 		goto err;
298 	}
299 
300 	if ((s = strdup(alpn)) == NULL) {
301 		tls_config_set_errorx(config, "out of memory");
302 		goto err;
303 	}
304 
305 	i = 0;
306 	q = s;
307 	while ((p = strsep(&q, ",")) != NULL) {
308 		if ((len = strlen(p)) == 0) {
309 			tls_config_set_errorx(config,
310 			    "alpn protocol with zero length");
311 			goto err;
312 		}
313 		if (len > 255) {
314 			tls_config_set_errorx(config,
315 			    "alpn protocol too long");
316 			goto err;
317 		}
318 		buf[i++] = len & 0xff;
319 		memcpy(&buf[i], p, len);
320 		i += len;
321 	}
322 
323 	free(s);
324 
325 	*alpn_data = buf;
326 	*alpn_len = buf_len;
327 
328 	return (0);
329 
330  err:
331 	free(buf);
332 	free(s);
333 
334 	return (-1);
335 }
336 
337 int
338 tls_config_set_alpn(struct tls_config *config, const char *alpn)
339 {
340 	return tls_config_parse_alpn(config, alpn, &config->alpn,
341 	    &config->alpn_len);
342 }
343 
344 static int
345 tls_config_add_keypair_file_internal(struct tls_config *config,
346     const char *cert_file, const char *key_file, const char *ocsp_file)
347 {
348 	struct tls_keypair *keypair;
349 
350 	if ((keypair = tls_keypair_new()) == NULL)
351 		return (-1);
352 	if (tls_keypair_set_cert_file(keypair, &config->error, cert_file) != 0)
353 		goto err;
354 	if (tls_keypair_set_key_file(keypair, &config->error, key_file) != 0)
355 		goto err;
356 	if (ocsp_file != NULL &&
357 	    tls_keypair_set_ocsp_staple_file(keypair, &config->error,
358 		ocsp_file) != 0)
359 		goto err;
360 
361 	tls_config_keypair_add(config, keypair);
362 
363 	return (0);
364 
365  err:
366 	tls_keypair_free(keypair);
367 	return (-1);
368 }
369 
370 static int
371 tls_config_add_keypair_mem_internal(struct tls_config *config, const uint8_t *cert,
372     size_t cert_len, const uint8_t *key, size_t key_len,
373     const uint8_t *staple, size_t staple_len)
374 {
375 	struct tls_keypair *keypair;
376 
377 	if ((keypair = tls_keypair_new()) == NULL)
378 		return (-1);
379 	if (tls_keypair_set_cert_mem(keypair, &config->error, cert, cert_len) != 0)
380 		goto err;
381 	if (tls_keypair_set_key_mem(keypair, &config->error, key, key_len) != 0)
382 		goto err;
383 	if (staple != NULL &&
384 	    tls_keypair_set_ocsp_staple_mem(keypair, &config->error, staple,
385 		staple_len) != 0)
386 		goto err;
387 
388 	tls_config_keypair_add(config, keypair);
389 
390 	return (0);
391 
392  err:
393 	tls_keypair_free(keypair);
394 	return (-1);
395 }
396 
397 int
398 tls_config_add_keypair_mem(struct tls_config *config, const uint8_t *cert,
399     size_t cert_len, const uint8_t *key, size_t key_len)
400 {
401 	return tls_config_add_keypair_mem_internal(config, cert, cert_len, key,
402 	    key_len, NULL, 0);
403 }
404 
405 int
406 tls_config_add_keypair_file(struct tls_config *config,
407     const char *cert_file, const char *key_file)
408 {
409 	return tls_config_add_keypair_file_internal(config, cert_file,
410 	    key_file, NULL);
411 }
412 
413 int
414 tls_config_add_keypair_ocsp_mem(struct tls_config *config, const uint8_t *cert,
415     size_t cert_len, const uint8_t *key, size_t key_len, const uint8_t *staple,
416     size_t staple_len)
417 {
418 	return tls_config_add_keypair_mem_internal(config, cert, cert_len, key,
419 	    key_len, staple, staple_len);
420 }
421 
422 int
423 tls_config_add_keypair_ocsp_file(struct tls_config *config,
424     const char *cert_file, const char *key_file, const char *ocsp_file)
425 {
426 	return tls_config_add_keypair_file_internal(config, cert_file,
427 	    key_file, ocsp_file);
428 }
429 
430 int
431 tls_config_set_ca_file(struct tls_config *config, const char *ca_file)
432 {
433 	return tls_config_load_file(&config->error, "CA", ca_file,
434 	    &config->ca_mem, &config->ca_len);
435 }
436 
437 int
438 tls_config_set_ca_path(struct tls_config *config, const char *ca_path)
439 {
440 	return tls_set_string(&config->ca_path, ca_path);
441 }
442 
443 int
444 tls_config_set_ca_mem(struct tls_config *config, const uint8_t *ca, size_t len)
445 {
446 	return tls_set_mem(&config->ca_mem, &config->ca_len, ca, len);
447 }
448 
449 int
450 tls_config_set_cert_file(struct tls_config *config, const char *cert_file)
451 {
452 	return tls_keypair_set_cert_file(config->keypair, &config->error,
453 	    cert_file);
454 }
455 
456 int
457 tls_config_set_cert_mem(struct tls_config *config, const uint8_t *cert,
458     size_t len)
459 {
460 	return tls_keypair_set_cert_mem(config->keypair, &config->error,
461 	    cert, len);
462 }
463 
464 int
465 tls_config_set_ciphers(struct tls_config *config, const char *ciphers)
466 {
467 	SSL_CTX *ssl_ctx = NULL;
468 
469 	if (ciphers == NULL ||
470 	    strcasecmp(ciphers, "default") == 0 ||
471 	    strcasecmp(ciphers, "secure") == 0)
472 		ciphers = TLS_CIPHERS_DEFAULT;
473 	else if (strcasecmp(ciphers, "compat") == 0)
474 		ciphers = TLS_CIPHERS_COMPAT;
475 	else if (strcasecmp(ciphers, "legacy") == 0)
476 		ciphers = TLS_CIPHERS_LEGACY;
477 	else if (strcasecmp(ciphers, "all") == 0 ||
478 	    strcasecmp(ciphers, "insecure") == 0)
479 		ciphers = TLS_CIPHERS_ALL;
480 
481 	if ((ssl_ctx = SSL_CTX_new(SSLv23_method())) == NULL) {
482 		tls_config_set_errorx(config, "out of memory");
483 		goto err;
484 	}
485 	if (SSL_CTX_set_cipher_list(ssl_ctx, ciphers) != 1) {
486 		tls_config_set_errorx(config, "no ciphers for '%s'", ciphers);
487 		goto err;
488 	}
489 
490 	SSL_CTX_free(ssl_ctx);
491 	return tls_set_string(&config->ciphers, ciphers);
492 
493  err:
494 	SSL_CTX_free(ssl_ctx);
495 	return -1;
496 }
497 
498 int
499 tls_config_set_crl_file(struct tls_config *config, const char *crl_file)
500 {
501 	return tls_config_load_file(&config->error, "CRL", crl_file,
502 	    &config->crl_mem, &config->crl_len);
503 }
504 
505 int
506 tls_config_set_crl_mem(struct tls_config *config, const uint8_t *crl,
507     size_t len)
508 {
509 	return tls_set_mem(&config->crl_mem, &config->crl_len, crl, len);
510 }
511 
512 int
513 tls_config_set_dheparams(struct tls_config *config, const char *params)
514 {
515 	int keylen;
516 
517 	if (params == NULL || strcasecmp(params, "none") == 0)
518 		keylen = 0;
519 	else if (strcasecmp(params, "auto") == 0)
520 		keylen = -1;
521 	else if (strcasecmp(params, "legacy") == 0)
522 		keylen = 1024;
523 	else {
524 		tls_config_set_errorx(config, "invalid dhe param '%s'", params);
525 		return (-1);
526 	}
527 
528 	config->dheparams = keylen;
529 
530 	return (0);
531 }
532 
533 int
534 tls_config_set_ecdhecurve(struct tls_config *config, const char *curve)
535 {
536 	if (curve == NULL ||
537 	    strcasecmp(curve, "none") == 0 ||
538 	    strcasecmp(curve, "auto") == 0) {
539 		curve = TLS_ECDHE_CURVES;
540 	} else if (strchr(curve, ',') != NULL || strchr(curve, ':') != NULL) {
541 		tls_config_set_errorx(config, "invalid ecdhe curve '%s'",
542 		    curve);
543 		return (-1);
544 	}
545 
546 	return tls_config_set_ecdhecurves(config, curve);
547 }
548 
549 int
550 tls_config_set_ecdhecurves(struct tls_config *config, const char *curves)
551 {
552 	int *curves_list = NULL, *curves_new;
553 	size_t curves_num = 0;
554 	char *cs = NULL;
555 	char *p, *q;
556 	int rv = -1;
557 	int nid;
558 
559 	free(config->ecdhecurves);
560 	config->ecdhecurves = NULL;
561 	config->ecdhecurves_len = 0;
562 
563 	if (curves == NULL || strcasecmp(curves, "default") == 0)
564 		curves = TLS_ECDHE_CURVES;
565 
566 	if ((cs = strdup(curves)) == NULL) {
567 		tls_config_set_errorx(config, "out of memory");
568 		goto err;
569 	}
570 
571 	q = cs;
572 	while ((p = strsep(&q, ",:")) != NULL) {
573 		while (*p == ' ' || *p == '\t')
574 			p++;
575 
576 		nid = OBJ_sn2nid(p);
577 		if (nid == NID_undef)
578 			nid = OBJ_ln2nid(p);
579 		if (nid == NID_undef)
580 			nid = EC_curve_nist2nid(p);
581 		if (nid == NID_undef) {
582 			tls_config_set_errorx(config,
583 			    "invalid ecdhe curve '%s'", p);
584 			goto err;
585 		}
586 
587 		if ((curves_new = reallocarray(curves_list, curves_num + 1,
588 		    sizeof(int))) == NULL) {
589 			tls_config_set_errorx(config, "out of memory");
590 			goto err;
591 		}
592 		curves_list = curves_new;
593 		curves_list[curves_num] = nid;
594 		curves_num++;
595 	}
596 
597 	config->ecdhecurves = curves_list;
598 	config->ecdhecurves_len = curves_num;
599 	curves_list = NULL;
600 
601 	rv = 0;
602 
603  err:
604 	free(cs);
605 	free(curves_list);
606 
607 	return (rv);
608 }
609 
610 int
611 tls_config_set_key_file(struct tls_config *config, const char *key_file)
612 {
613 	return tls_keypair_set_key_file(config->keypair, &config->error,
614 	    key_file);
615 }
616 
617 int
618 tls_config_set_key_mem(struct tls_config *config, const uint8_t *key,
619     size_t len)
620 {
621 	return tls_keypair_set_key_mem(config->keypair, &config->error,
622 	    key, len);
623 }
624 
625 static int
626 tls_config_set_keypair_file_internal(struct tls_config *config,
627     const char *cert_file, const char *key_file, const char *ocsp_file)
628 {
629 	if (tls_config_set_cert_file(config, cert_file) != 0)
630 		return (-1);
631 	if (tls_config_set_key_file(config, key_file) != 0)
632 		return (-1);
633 	if (ocsp_file != NULL &&
634 	    tls_config_set_ocsp_staple_file(config, ocsp_file) != 0)
635 		return (-1);
636 
637 	return (0);
638 }
639 
640 static int
641 tls_config_set_keypair_mem_internal(struct tls_config *config, const uint8_t *cert,
642     size_t cert_len, const uint8_t *key, size_t key_len,
643     const uint8_t *staple, size_t staple_len)
644 {
645 	if (tls_config_set_cert_mem(config, cert, cert_len) != 0)
646 		return (-1);
647 	if (tls_config_set_key_mem(config, key, key_len) != 0)
648 		return (-1);
649 	if ((staple != NULL) &&
650 	    (tls_config_set_ocsp_staple_mem(config, staple, staple_len) != 0))
651 		return (-1);
652 
653 	return (0);
654 }
655 
656 int
657 tls_config_set_keypair_file(struct tls_config *config,
658     const char *cert_file, const char *key_file)
659 {
660 	return tls_config_set_keypair_file_internal(config, cert_file, key_file,
661 	    NULL);
662 }
663 
664 int
665 tls_config_set_keypair_mem(struct tls_config *config, const uint8_t *cert,
666     size_t cert_len, const uint8_t *key, size_t key_len)
667 {
668 	return tls_config_set_keypair_mem_internal(config, cert, cert_len,
669 	    key, key_len, NULL, 0);
670 }
671 
672 int
673 tls_config_set_keypair_ocsp_file(struct tls_config *config,
674     const char *cert_file, const char *key_file, const char *ocsp_file)
675 {
676 	return tls_config_set_keypair_file_internal(config, cert_file, key_file,
677 	    ocsp_file);
678 }
679 
680 int
681 tls_config_set_keypair_ocsp_mem(struct tls_config *config, const uint8_t *cert,
682     size_t cert_len, const uint8_t *key, size_t key_len,
683     const uint8_t *staple, size_t staple_len)
684 {
685 	return tls_config_set_keypair_mem_internal(config, cert, cert_len,
686 	    key, key_len, staple, staple_len);
687 }
688 
689 
690 int
691 tls_config_set_protocols(struct tls_config *config, uint32_t protocols)
692 {
693 	config->protocols = protocols;
694 
695 	return (0);
696 }
697 
698 int
699 tls_config_set_session_fd(struct tls_config *config, int session_fd)
700 {
701 	struct stat sb;
702 	mode_t mugo;
703 
704 	if (session_fd == -1) {
705 		config->session_fd = session_fd;
706 		return (0);
707 	}
708 
709 	if (fstat(session_fd, &sb) == -1) {
710 		tls_config_set_error(config, "failed to stat session file");
711 		return (-1);
712 	}
713 	if (!S_ISREG(sb.st_mode)) {
714 		tls_config_set_errorx(config,
715 		    "session file is not a regular file");
716 		return (-1);
717 	}
718 
719 	if (sb.st_uid != getuid()) {
720 		tls_config_set_errorx(config, "session file has incorrect "
721 		    "owner (uid %i != %i)", sb.st_uid, getuid());
722 		return (-1);
723 	}
724 	mugo = sb.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO);
725 	if (mugo != (S_IRUSR|S_IWUSR)) {
726 		tls_config_set_errorx(config, "session file has incorrect "
727 		    "permissions (%o != 600)", mugo);
728 		return (-1);
729 	}
730 
731 	config->session_fd = session_fd;
732 
733 	return (0);
734 }
735 
736 int
737 tls_config_set_verify_depth(struct tls_config *config, int verify_depth)
738 {
739 	config->verify_depth = verify_depth;
740 
741 	return (0);
742 }
743 
744 void
745 tls_config_prefer_ciphers_client(struct tls_config *config)
746 {
747 	config->ciphers_server = 0;
748 }
749 
750 void
751 tls_config_prefer_ciphers_server(struct tls_config *config)
752 {
753 	config->ciphers_server = 1;
754 }
755 
756 void
757 tls_config_insecure_noverifycert(struct tls_config *config)
758 {
759 	config->verify_cert = 0;
760 }
761 
762 void
763 tls_config_insecure_noverifyname(struct tls_config *config)
764 {
765 	config->verify_name = 0;
766 }
767 
768 void
769 tls_config_insecure_noverifytime(struct tls_config *config)
770 {
771 	config->verify_time = 0;
772 }
773 
774 void
775 tls_config_verify(struct tls_config *config)
776 {
777 	config->verify_cert = 1;
778 	config->verify_name = 1;
779 	config->verify_time = 1;
780 }
781 
782 void
783 tls_config_ocsp_require_stapling(struct tls_config *config)
784 {
785 	config->ocsp_require_stapling = 1;
786 }
787 
788 void
789 tls_config_verify_client(struct tls_config *config)
790 {
791 	config->verify_client = 1;
792 }
793 
794 void
795 tls_config_verify_client_optional(struct tls_config *config)
796 {
797 	config->verify_client = 2;
798 }
799 
800 void
801 tls_config_skip_private_key_check(struct tls_config *config)
802 {
803 	config->skip_private_key_check = 1;
804 }
805 
806 int
807 tls_config_set_ocsp_staple_file(struct tls_config *config, const char *staple_file)
808 {
809 	return tls_keypair_set_ocsp_staple_file(config->keypair, &config->error,
810 	    staple_file);
811 }
812 
813 int
814 tls_config_set_ocsp_staple_mem(struct tls_config *config, const uint8_t *staple,
815     size_t len)
816 {
817 	return tls_keypair_set_ocsp_staple_mem(config->keypair, &config->error,
818 	    staple, len);
819 }
820 
821 int
822 tls_config_set_session_id(struct tls_config *config,
823     const unsigned char *session_id, size_t len)
824 {
825 	if (len > TLS_MAX_SESSION_ID_LENGTH) {
826 		tls_config_set_errorx(config, "session ID too large");
827 		return (-1);
828 	}
829 	memset(config->session_id, 0, sizeof(config->session_id));
830 	memcpy(config->session_id, session_id, len);
831 	return (0);
832 }
833 
834 int
835 tls_config_set_session_lifetime(struct tls_config *config, int lifetime)
836 {
837 	if (lifetime > TLS_MAX_SESSION_TIMEOUT) {
838 		tls_config_set_errorx(config, "session lifetime too large");
839 		return (-1);
840 	}
841 	if (lifetime != 0 && lifetime < TLS_MIN_SESSION_TIMEOUT) {
842 		tls_config_set_errorx(config, "session lifetime too small");
843 		return (-1);
844 	}
845 
846 	config->session_lifetime = lifetime;
847 	return (0);
848 }
849 
850 int
851 tls_config_add_ticket_key(struct tls_config *config, uint32_t keyrev,
852     unsigned char *key, size_t keylen)
853 {
854 	struct tls_ticket_key newkey;
855 	int i;
856 
857 	if (TLS_TICKET_KEY_SIZE != keylen ||
858 	    sizeof(newkey.aes_key) + sizeof(newkey.hmac_key) > keylen) {
859 		tls_config_set_errorx(config,
860 		    "wrong amount of ticket key data");
861 		return (-1);
862 	}
863 
864 	keyrev = htonl(keyrev);
865 	memset(&newkey, 0, sizeof(newkey));
866 	memcpy(newkey.key_name, &keyrev, sizeof(keyrev));
867 	memcpy(newkey.aes_key, key, sizeof(newkey.aes_key));
868 	memcpy(newkey.hmac_key, key + sizeof(newkey.aes_key),
869 	    sizeof(newkey.hmac_key));
870 	newkey.time = time(NULL);
871 
872 	for (i = 0; i < TLS_NUM_TICKETS; i++) {
873 		struct tls_ticket_key *tk = &config->ticket_keys[i];
874 		if (memcmp(newkey.key_name, tk->key_name,
875 		    sizeof(tk->key_name)) != 0)
876 			continue;
877 
878 		/* allow re-entry of most recent key */
879 		if (i == 0 && memcmp(newkey.aes_key, tk->aes_key,
880 		    sizeof(tk->aes_key)) == 0 && memcmp(newkey.hmac_key,
881 		    tk->hmac_key, sizeof(tk->hmac_key)) == 0)
882 			return (0);
883 		tls_config_set_errorx(config, "ticket key already present");
884 		return (-1);
885 	}
886 
887 	memmove(&config->ticket_keys[1], &config->ticket_keys[0],
888 	    sizeof(config->ticket_keys) - sizeof(config->ticket_keys[0]));
889 	config->ticket_keys[0] = newkey;
890 
891 	config->ticket_autorekey = 0;
892 
893 	return (0);
894 }
895 
896 int
897 tls_config_ticket_autorekey(struct tls_config *config)
898 {
899 	unsigned char key[TLS_TICKET_KEY_SIZE];
900 	int rv;
901 
902 	arc4random_buf(key, sizeof(key));
903 	rv = tls_config_add_ticket_key(config, config->ticket_keyrev++, key,
904 	    sizeof(key));
905 	config->ticket_autorekey = 1;
906 	return (rv);
907 }
908