crypto/libressl/tls/tls_config.c

   1 /* $OpenBSD: tls_config.c,v 1.65 2022/01/25 21:51:24 eric 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         pthread_mutex_destroy(&config->mutex);
 183
 184         free(config);
 185 }
 186
 187 static void
 188 tls_config_keypair_add(struct tls_config *config, struct tls_keypair *keypair)
 189 {
 190         struct tls_keypair *kp;
 191
 192         kp = config->keypair;
 193         while (kp->next != NULL)
 194                 kp = kp->next;
 195
 196         kp->next = keypair;
 197 }
 198
 199 const char *
 200 tls_config_error(struct tls_config *config)
 201 {
 202         return config->error.msg;
 203 }
 204
 205 void
 206 tls_config_clear_keys(struct tls_config *config)
 207 {
 208         struct tls_keypair *kp;
 209
 210         for (kp = config->keypair; kp != NULL; kp = kp->next)
 211                 tls_keypair_clear_key(kp);
 212 }
 213
 214 int
 215 tls_config_parse_protocols(uint32_t *protocols, const char *protostr)
 216 {
 217         uint32_t proto, protos = 0;
 218         char *s, *p, *q;
 219         int negate;
 220
 221         if (protostr == NULL) {
 222                 *protocols = TLS_PROTOCOLS_DEFAULT;
 223                 return (0);
 224         }
 225
 226         if ((s = strdup(protostr)) == NULL)
 227                 return (-1);
 228
 229         q = s;
 230         while ((p = strsep(&q, ",:")) != NULL) {
 231                 while (*p == ' ' || *p == '\t')
 232                         p++;
 233
 234                 negate = 0;
 235                 if (*p == '!') {
 236                         negate = 1;
 237                         p++;
 238                 }
 239
 240                 if (negate && protos == 0)
 241                         protos = TLS_PROTOCOLS_ALL;
 242
 243                 proto = 0;
 244                 if (strcasecmp(p, "all") == 0 ||
 245                     strcasecmp(p, "legacy") == 0)
 246                         proto = TLS_PROTOCOLS_ALL;
 247                 else if (strcasecmp(p, "default") == 0 ||
 248                     strcasecmp(p, "secure") == 0)
 249                         proto = TLS_PROTOCOLS_DEFAULT;
 250                 if (strcasecmp(p, "tlsv1") == 0)
 251                         proto = TLS_PROTOCOL_TLSv1;
 252                 else if (strcasecmp(p, "tlsv1.0") == 0)
 253                         proto = TLS_PROTOCOL_TLSv1_0;
 254                 else if (strcasecmp(p, "tlsv1.1") == 0)
 255                         proto = TLS_PROTOCOL_TLSv1_1;
 256                 else if (strcasecmp(p, "tlsv1.2") == 0)
 257                         proto = TLS_PROTOCOL_TLSv1_2;
 258                 else if (strcasecmp(p, "tlsv1.3") == 0)
 259                         proto = TLS_PROTOCOL_TLSv1_3;
 260
 261                 if (proto == 0) {
 262                         free(s);
 263                         return (-1);
 264                 }
 265
 266                 if (negate)
 267                         protos &= ~proto;
 268                 else
 269                         protos |= proto;
 270         }
 271
 272         *protocols = protos;
 273
 274         free(s);
 275
 276         return (0);
 277 }
 278
 279 static int
 280 tls_config_parse_alpn(struct tls_config *config, const char *alpn,
 281     char **alpn_data, size_t *alpn_len)
 282 {
 283         size_t buf_len, i, len;
 284         char *buf = NULL;
 285         char *s = NULL;
 286         char *p, *q;
 287
 288         free(*alpn_data);
 289         *alpn_data = NULL;
 290         *alpn_len = 0;
 291
 292         if ((buf_len = strlen(alpn) + 1) > 65535) {
 293                 tls_config_set_errorx(config, "alpn too large");
 294                 goto err;
 295         }
 296
 297         if ((buf = malloc(buf_len)) == NULL) {
 298                 tls_config_set_errorx(config, "out of memory");
 299                 goto err;
 300         }
 301
 302         if ((s = strdup(alpn)) == NULL) {
 303                 tls_config_set_errorx(config, "out of memory");
 304                 goto err;
 305         }
 306
 307         i = 0;
 308         q = s;
 309         while ((p = strsep(&q, ",")) != NULL) {
 310                 if ((len = strlen(p)) == 0) {
 311                         tls_config_set_errorx(config,
 312                             "alpn protocol with zero length");
 313                         goto err;
 314                 }
 315                 if (len > 255) {
 316                         tls_config_set_errorx(config,
 317                             "alpn protocol too long");
 318                         goto err;
 319                 }
 320                 buf[i++] = len & 0xff;
 321                 memcpy(&buf[i], p, len);
 322                 i += len;
 323         }
 324
 325         free(s);
 326
 327         *alpn_data = buf;
 328         *alpn_len = buf_len;
 329
 330         return (0);
 331
 332  err:
 333         free(buf);
 334         free(s);
 335
 336         return (-1);
 337 }
 338
 339 int
 340 tls_config_set_alpn(struct tls_config *config, const char *alpn)
 341 {
 342         return tls_config_parse_alpn(config, alpn, &config->alpn,
 343             &config->alpn_len);
 344 }
 345
 346 static int
 347 tls_config_add_keypair_file_internal(struct tls_config *config,
 348     const char *cert_file, const char *key_file, const char *ocsp_file)
 349 {
 350         struct tls_keypair *keypair;
 351
 352         if ((keypair = tls_keypair_new()) == NULL)
 353                 return (-1);
 354         if (tls_keypair_set_cert_file(keypair, &config->error, cert_file) != 0)
 355                 goto err;
 356         if (key_file != NULL &&
 357             tls_keypair_set_key_file(keypair, &config->error, key_file) != 0)
 358                 goto err;
 359         if (ocsp_file != NULL &&
 360             tls_keypair_set_ocsp_staple_file(keypair, &config->error,
 361                 ocsp_file) != 0)
 362                 goto err;
 363
 364         tls_config_keypair_add(config, keypair);
 365
 366         return (0);
 367
 368  err:
 369         tls_keypair_free(keypair);
 370         return (-1);
 371 }
 372
 373 static int
 374 tls_config_add_keypair_mem_internal(struct tls_config *config, const uint8_t *cert,
 375     size_t cert_len, const uint8_t *key, size_t key_len,
 376     const uint8_t *staple, size_t staple_len)
 377 {
 378         struct tls_keypair *keypair;
 379
 380         if ((keypair = tls_keypair_new()) == NULL)
 381                 return (-1);
 382         if (tls_keypair_set_cert_mem(keypair, &config->error, cert, cert_len) != 0)
 383                 goto err;
 384         if (key != NULL &&
 385             tls_keypair_set_key_mem(keypair, &config->error, key, key_len) != 0)
 386                 goto err;
 387         if (staple != NULL &&
 388             tls_keypair_set_ocsp_staple_mem(keypair, &config->error, staple,
 389                 staple_len) != 0)
 390                 goto err;
 391
 392         tls_config_keypair_add(config, keypair);
 393
 394         return (0);
 395
 396  err:
 397         tls_keypair_free(keypair);
 398         return (-1);
 399 }
 400
 401 int
 402 tls_config_add_keypair_mem(struct tls_config *config, const uint8_t *cert,
 403     size_t cert_len, const uint8_t *key, size_t key_len)
 404 {
 405         return tls_config_add_keypair_mem_internal(config, cert, cert_len, key,
 406             key_len, NULL, 0);
 407 }
 408
 409 int
 410 tls_config_add_keypair_file(struct tls_config *config,
 411     const char *cert_file, const char *key_file)
 412 {
 413         return tls_config_add_keypair_file_internal(config, cert_file,
 414             key_file, NULL);
 415 }
 416
 417 int
 418 tls_config_add_keypair_ocsp_mem(struct tls_config *config, const uint8_t *cert,
 419     size_t cert_len, const uint8_t *key, size_t key_len, const uint8_t *staple,
 420     size_t staple_len)
 421 {
 422         return tls_config_add_keypair_mem_internal(config, cert, cert_len, key,
 423             key_len, staple, staple_len);
 424 }
 425
 426 int
 427 tls_config_add_keypair_ocsp_file(struct tls_config *config,
 428     const char *cert_file, const char *key_file, const char *ocsp_file)
 429 {
 430         return tls_config_add_keypair_file_internal(config, cert_file,
 431             key_file, ocsp_file);
 432 }
 433
 434 int
 435 tls_config_set_ca_file(struct tls_config *config, const char *ca_file)
 436 {
 437         return tls_config_load_file(&config->error, "CA", ca_file,
 438             &config->ca_mem, &config->ca_len);
 439 }
 440
 441 int
 442 tls_config_set_ca_path(struct tls_config *config, const char *ca_path)
 443 {
 444         return tls_set_string(&config->ca_path, ca_path);
 445 }
 446
 447 int
 448 tls_config_set_ca_mem(struct tls_config *config, const uint8_t *ca, size_t len)
 449 {
 450         return tls_set_mem(&config->ca_mem, &config->ca_len, ca, len);
 451 }
 452
 453 int
 454 tls_config_set_cert_file(struct tls_config *config, const char *cert_file)
 455 {
 456         return tls_keypair_set_cert_file(config->keypair, &config->error,
 457             cert_file);
 458 }
 459
 460 int
 461 tls_config_set_cert_mem(struct tls_config *config, const uint8_t *cert,
 462     size_t len)
 463 {
 464         return tls_keypair_set_cert_mem(config->keypair, &config->error,
 465             cert, len);
 466 }
 467
 468 int
 469 tls_config_set_ciphers(struct tls_config *config, const char *ciphers)
 470 {
 471         SSL_CTX *ssl_ctx = NULL;
 472
 473         if (ciphers == NULL ||
 474             strcasecmp(ciphers, "default") == 0 ||
 475             strcasecmp(ciphers, "secure") == 0)
 476                 ciphers = TLS_CIPHERS_DEFAULT;
 477         else if (strcasecmp(ciphers, "compat") == 0)
 478                 ciphers = TLS_CIPHERS_COMPAT;
 479         else if (strcasecmp(ciphers, "legacy") == 0)
 480                 ciphers = TLS_CIPHERS_LEGACY;
 481         else if (strcasecmp(ciphers, "all") == 0 ||
 482             strcasecmp(ciphers, "insecure") == 0)
 483                 ciphers = TLS_CIPHERS_ALL;
 484
 485         if ((ssl_ctx = SSL_CTX_new(SSLv23_method())) == NULL) {
 486                 tls_config_set_errorx(config, "out of memory");
 487                 goto err;
 488         }
 489         if (SSL_CTX_set_cipher_list(ssl_ctx, ciphers) != 1) {
 490                 tls_config_set_errorx(config, "no ciphers for '%s'", ciphers);
 491                 goto err;
 492         }
 493
 494         SSL_CTX_free(ssl_ctx);
 495         return tls_set_string(&config->ciphers, ciphers);
 496
 497  err:
 498         SSL_CTX_free(ssl_ctx);
 499         return -1;
 500 }
 501
 502 int
 503 tls_config_set_crl_file(struct tls_config *config, const char *crl_file)
 504 {
 505         return tls_config_load_file(&config->error, "CRL", crl_file,
 506             &config->crl_mem, &config->crl_len);
 507 }
 508
 509 int
 510 tls_config_set_crl_mem(struct tls_config *config, const uint8_t *crl,
 511     size_t len)
 512 {
 513         return tls_set_mem(&config->crl_mem, &config->crl_len, crl, len);
 514 }
 515
 516 int
 517 tls_config_set_dheparams(struct tls_config *config, const char *params)
 518 {
 519         int keylen;
 520
 521         if (params == NULL || strcasecmp(params, "none") == 0)
 522                 keylen = 0;
 523         else if (strcasecmp(params, "auto") == 0)
 524                 keylen = -1;
 525         else if (strcasecmp(params, "legacy") == 0)
 526                 keylen = 1024;
 527         else {
 528                 tls_config_set_errorx(config, "invalid dhe param '%s'", params);
 529                 return (-1);
 530         }
 531
 532         config->dheparams = keylen;
 533
 534         return (0);
 535 }
 536
 537 int
 538 tls_config_set_ecdhecurve(struct tls_config *config, const char *curve)
 539 {
 540         if (curve == NULL ||
 541             strcasecmp(curve, "none") == 0 ||
 542             strcasecmp(curve, "auto") == 0) {
 543                 curve = TLS_ECDHE_CURVES;
 544         } else if (strchr(curve, ',') != NULL || strchr(curve, ':') != NULL) {
 545                 tls_config_set_errorx(config, "invalid ecdhe curve '%s'",
 546                     curve);
 547                 return (-1);
 548         }
 549
 550         return tls_config_set_ecdhecurves(config, curve);
 551 }
 552
 553 int
 554 tls_config_set_ecdhecurves(struct tls_config *config, const char *curves)
 555 {
 556         int *curves_list = NULL, *curves_new;
 557         size_t curves_num = 0;
 558         char *cs = NULL;
 559         char *p, *q;
 560         int rv = -1;
 561         int nid;
 562
 563         free(config->ecdhecurves);
 564         config->ecdhecurves = NULL;
 565         config->ecdhecurves_len = 0;
 566
 567         if (curves == NULL || strcasecmp(curves, "default") == 0)
 568                 curves = TLS_ECDHE_CURVES;
 569
 570         if ((cs = strdup(curves)) == NULL) {
 571                 tls_config_set_errorx(config, "out of memory");
 572                 goto err;
 573         }
 574
 575         q = cs;
 576         while ((p = strsep(&q, ",:")) != NULL) {
 577                 while (*p == ' ' || *p == '\t')
 578                         p++;
 579
 580                 nid = OBJ_sn2nid(p);
 581                 if (nid == NID_undef)
 582                         nid = OBJ_ln2nid(p);
 583                 if (nid == NID_undef)
 584                         nid = EC_curve_nist2nid(p);
 585                 if (nid == NID_undef) {
 586                         tls_config_set_errorx(config,
 587                             "invalid ecdhe curve '%s'", p);
 588                         goto err;
 589                 }
 590
 591                 if ((curves_new = reallocarray(curves_list, curves_num + 1,
 592                     sizeof(int))) == NULL) {
 593                         tls_config_set_errorx(config, "out of memory");
 594                         goto err;
 595                 }
 596                 curves_list = curves_new;
 597                 curves_list[curves_num] = nid;
 598                 curves_num++;
 599         }
 600
 601         config->ecdhecurves = curves_list;
 602         config->ecdhecurves_len = curves_num;
 603         curves_list = NULL;
 604
 605         rv = 0;
 606
 607  err:
 608         free(cs);
 609         free(curves_list);
 610
 611         return (rv);
 612 }
 613
 614 int
 615 tls_config_set_key_file(struct tls_config *config, const char *key_file)
 616 {
 617         return tls_keypair_set_key_file(config->keypair, &config->error,
 618             key_file);
 619 }
 620
 621 int
 622 tls_config_set_key_mem(struct tls_config *config, const uint8_t *key,
 623     size_t len)
 624 {
 625         return tls_keypair_set_key_mem(config->keypair, &config->error,
 626             key, len);
 627 }
 628
 629 static int
 630 tls_config_set_keypair_file_internal(struct tls_config *config,
 631     const char *cert_file, const char *key_file, const char *ocsp_file)
 632 {
 633         if (tls_config_set_cert_file(config, cert_file) != 0)
 634                 return (-1);
 635         if (tls_config_set_key_file(config, key_file) != 0)
 636                 return (-1);
 637         if (ocsp_file != NULL &&
 638             tls_config_set_ocsp_staple_file(config, ocsp_file) != 0)
 639                 return (-1);
 640
 641         return (0);
 642 }
 643
 644 static int
 645 tls_config_set_keypair_mem_internal(struct tls_config *config, const uint8_t *cert,
 646     size_t cert_len, const uint8_t *key, size_t key_len,
 647     const uint8_t *staple, size_t staple_len)
 648 {
 649         if (tls_config_set_cert_mem(config, cert, cert_len) != 0)
 650                 return (-1);
 651         if (tls_config_set_key_mem(config, key, key_len) != 0)
 652                 return (-1);
 653         if ((staple != NULL) &&
 654             (tls_config_set_ocsp_staple_mem(config, staple, staple_len) != 0))
 655                 return (-1);
 656
 657         return (0);
 658 }
 659
 660 int
 661 tls_config_set_keypair_file(struct tls_config *config,
 662     const char *cert_file, const char *key_file)
 663 {
 664         return tls_config_set_keypair_file_internal(config, cert_file, key_file,
 665             NULL);
 666 }
 667
 668 int
 669 tls_config_set_keypair_mem(struct tls_config *config, const uint8_t *cert,
 670     size_t cert_len, const uint8_t *key, size_t key_len)
 671 {
 672         return tls_config_set_keypair_mem_internal(config, cert, cert_len,
 673             key, key_len, NULL, 0);
 674 }
 675
 676 int
 677 tls_config_set_keypair_ocsp_file(struct tls_config *config,
 678     const char *cert_file, const char *key_file, const char *ocsp_file)
 679 {
 680         return tls_config_set_keypair_file_internal(config, cert_file, key_file,
 681             ocsp_file);
 682 }
 683
 684 int
 685 tls_config_set_keypair_ocsp_mem(struct tls_config *config, const uint8_t *cert,
 686     size_t cert_len, const uint8_t *key, size_t key_len,
 687     const uint8_t *staple, size_t staple_len)
 688 {
 689         return tls_config_set_keypair_mem_internal(config, cert, cert_len,
 690             key, key_len, staple, staple_len);
 691 }
 692
 693
 694 int
 695 tls_config_set_protocols(struct tls_config *config, uint32_t protocols)
 696 {
 697         config->protocols = protocols;
 698
 699         return (0);
 700 }
 701
 702 int
 703 tls_config_set_session_fd(struct tls_config *config, int session_fd)
 704 {
 705         struct stat sb;
 706         mode_t mugo;
 707
 708         if (session_fd == -1) {
 709                 config->session_fd = session_fd;
 710                 return (0);
 711         }
 712
 713         if (fstat(session_fd, &sb) == -1) {
 714                 tls_config_set_error(config, "failed to stat session file");
 715                 return (-1);
 716         }
 717         if (!S_ISREG(sb.st_mode)) {
 718                 tls_config_set_errorx(config,
 719                     "session file is not a regular file");
 720                 return (-1);
 721         }
 722
 723         if (sb.st_uid != getuid()) {
 724                 tls_config_set_errorx(config, "session file has incorrect "
 725                     "owner (uid %u != %u)", sb.st_uid, getuid());
 726                 return (-1);
 727         }
 728         mugo = sb.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO);
 729         if (mugo != (S_IRUSR|S_IWUSR)) {
 730                 tls_config_set_errorx(config, "session file has incorrect "
 731                     "permissions (%o != 600)", mugo);
 732                 return (-1);
 733         }
 734
 735         config->session_fd = session_fd;
 736
 737         return (0);
 738 }
 739
 740 int
 741 tls_config_set_sign_cb(struct tls_config *config, tls_sign_cb cb, void *cb_arg)
 742 {
 743         config->use_fake_private_key = 1;
 744         config->skip_private_key_check = 1;
 745         config->sign_cb = cb;
 746         config->sign_cb_arg = cb_arg;
 747
 748         return (0);
 749 }
 750
 751 int
 752 tls_config_set_verify_depth(struct tls_config *config, int verify_depth)
 753 {
 754         config->verify_depth = verify_depth;
 755
 756         return (0);
 757 }
 758
 759 void
 760 tls_config_prefer_ciphers_client(struct tls_config *config)
 761 {
 762         config->ciphers_server = 0;
 763 }
 764
 765 void
 766 tls_config_prefer_ciphers_server(struct tls_config *config)
 767 {
 768         config->ciphers_server = 1;
 769 }
 770
 771 void
 772 tls_config_insecure_noverifycert(struct tls_config *config)
 773 {
 774         config->verify_cert = 0;
 775 }
 776
 777 void
 778 tls_config_insecure_noverifyname(struct tls_config *config)
 779 {
 780         config->verify_name = 0;
 781 }
 782
 783 void
 784 tls_config_insecure_noverifytime(struct tls_config *config)
 785 {
 786         config->verify_time = 0;
 787 }
 788
 789 void
 790 tls_config_verify(struct tls_config *config)
 791 {
 792         config->verify_cert = 1;
 793         config->verify_name = 1;
 794         config->verify_time = 1;
 795 }
 796
 797 void
 798 tls_config_ocsp_require_stapling(struct tls_config *config)
 799 {
 800         config->ocsp_require_stapling = 1;
 801 }
 802
 803 void
 804 tls_config_verify_client(struct tls_config *config)
 805 {
 806         config->verify_client = 1;
 807 }
 808
 809 void
 810 tls_config_verify_client_optional(struct tls_config *config)
 811 {
 812         config->verify_client = 2;
 813 }
 814
 815 void
 816 tls_config_skip_private_key_check(struct tls_config *config)
 817 {
 818         config->skip_private_key_check = 1;
 819 }
 820
 821 void
 822 tls_config_use_fake_private_key(struct tls_config *config)
 823 {
 824         config->use_fake_private_key = 1;
 825         config->skip_private_key_check = 1;
 826 }
 827
 828 int
 829 tls_config_set_ocsp_staple_file(struct tls_config *config, const char *staple_file)
 830 {
 831         return tls_keypair_set_ocsp_staple_file(config->keypair, &config->error,
 832             staple_file);
 833 }
 834
 835 int
 836 tls_config_set_ocsp_staple_mem(struct tls_config *config, const uint8_t *staple,
 837     size_t len)
 838 {
 839         return tls_keypair_set_ocsp_staple_mem(config->keypair, &config->error,
 840             staple, len);
 841 }
 842
 843 int
 844 tls_config_set_session_id(struct tls_config *config,
 845     const unsigned char *session_id, size_t len)
 846 {
 847         if (len > TLS_MAX_SESSION_ID_LENGTH) {
 848                 tls_config_set_errorx(config, "session ID too large");
 849                 return (-1);
 850         }
 851         memset(config->session_id, 0, sizeof(config->session_id));
 852         memcpy(config->session_id, session_id, len);
 853         return (0);
 854 }
 855
 856 int
 857 tls_config_set_session_lifetime(struct tls_config *config, int lifetime)
 858 {
 859         if (lifetime > TLS_MAX_SESSION_TIMEOUT) {
 860                 tls_config_set_errorx(config, "session lifetime too large");
 861                 return (-1);
 862         }
 863         if (lifetime != 0 && lifetime < TLS_MIN_SESSION_TIMEOUT) {
 864                 tls_config_set_errorx(config, "session lifetime too small");
 865                 return (-1);
 866         }
 867
 868         config->session_lifetime = lifetime;
 869         return (0);
 870 }
 871
 872 int
 873 tls_config_add_ticket_key(struct tls_config *config, uint32_t keyrev,
 874     unsigned char *key, size_t keylen)
 875 {
 876         struct tls_ticket_key newkey;
 877         int i;
 878
 879         if (TLS_TICKET_KEY_SIZE != keylen ||
 880             sizeof(newkey.aes_key) + sizeof(newkey.hmac_key) > keylen) {
 881                 tls_config_set_errorx(config,
 882                     "wrong amount of ticket key data");
 883                 return (-1);
 884         }
 885
 886         keyrev = htonl(keyrev);
 887         memset(&newkey, 0, sizeof(newkey));
 888         memcpy(newkey.key_name, &keyrev, sizeof(keyrev));
 889         memcpy(newkey.aes_key, key, sizeof(newkey.aes_key));
 890         memcpy(newkey.hmac_key, key + sizeof(newkey.aes_key),
 891             sizeof(newkey.hmac_key));
 892         newkey.time = time(NULL);
 893
 894         for (i = 0; i < TLS_NUM_TICKETS; i++) {
 895                 struct tls_ticket_key *tk = &config->ticket_keys[i];
 896                 if (memcmp(newkey.key_name, tk->key_name,
 897                     sizeof(tk->key_name)) != 0)
 898                         continue;
 899
 900                 /* allow re-entry of most recent key */
 901                 if (i == 0 && memcmp(newkey.aes_key, tk->aes_key,
 902                     sizeof(tk->aes_key)) == 0 && memcmp(newkey.hmac_key,
 903                     tk->hmac_key, sizeof(tk->hmac_key)) == 0)
 904                         return (0);
 905                 tls_config_set_errorx(config, "ticket key already present");
 906                 return (-1);
 907         }
 908
 909         memmove(&config->ticket_keys[1], &config->ticket_keys[0],
 910             sizeof(config->ticket_keys) - sizeof(config->ticket_keys[0]));
 911         config->ticket_keys[0] = newkey;
 912
 913         config->ticket_autorekey = 0;
 914
 915         return (0);
 916 }
 917
 918 int
 919 tls_config_ticket_autorekey(struct tls_config *config)
 920 {
 921         unsigned char key[TLS_TICKET_KEY_SIZE];
 922         int rv;
 923
 924         arc4random_buf(key, sizeof(key));
 925         rv = tls_config_add_ticket_key(config, config->ticket_keyrev++, key,
 926             sizeof(key));
 927         config->ticket_autorekey = 1;
 928         return (rv);
 929 }