ssl/ssl_cert.c

   1 /*
   2  * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <stdio.h>
  12 #include <sys/types.h>
  13
  14 #include "internal/nelem.h"
  15 #include "internal/o_dir.h"
  16 #include <openssl/bio.h>
  17 #include <openssl/pem.h>
  18 #include <openssl/store.h>
  19 #include <openssl/x509v3.h>
  20 #include <openssl/dh.h>
  21 #include <openssl/bn.h>
  22 #include <openssl/crypto.h>
  23 #include "internal/refcount.h"
  24 #include "ssl_local.h"
  25 #include "ssl_cert_table.h"
  26 #include "internal/thread_once.h"
  27
  28 static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
  29                                          int op, int bits, int nid, void *other,
  30                                          void *ex);
  31
  32 static CRYPTO_ONCE ssl_x509_store_ctx_once = CRYPTO_ONCE_STATIC_INIT;
  33 static volatile int ssl_x509_store_ctx_idx = -1;
  34
  35 DEFINE_RUN_ONCE_STATIC(ssl_x509_store_ctx_init)
  36 {
  37     ssl_x509_store_ctx_idx = X509_STORE_CTX_get_ex_new_index(0,
  38                                                              "SSL for verify callback",
  39                                                              NULL, NULL, NULL);
  40     return ssl_x509_store_ctx_idx >= 0;
  41 }
  42
  43 int SSL_get_ex_data_X509_STORE_CTX_idx(void)
  44 {
  45
  46     if (!RUN_ONCE(&ssl_x509_store_ctx_once, ssl_x509_store_ctx_init))
  47         return -1;
  48     return ssl_x509_store_ctx_idx;
  49 }
  50
  51 CERT *ssl_cert_new(void)
  52 {
  53     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
  54
  55     if (ret == NULL)
  56         return NULL;
  57
  58     ret->key = &(ret->pkeys[SSL_PKEY_RSA]);
  59     ret->references = 1;
  60     ret->sec_cb = ssl_security_default_callback;
  61     ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
  62     ret->sec_ex = NULL;
  63     ret->lock = CRYPTO_THREAD_lock_new();
  64     if (ret->lock == NULL) {
  65         ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
  66         OPENSSL_free(ret);
  67         return NULL;
  68     }
  69
  70     return ret;
  71 }
  72
  73 CERT *ssl_cert_dup(CERT *cert)
  74 {
  75     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
  76     int i;
  77 #ifndef OPENSSL_NO_COMP_ALG
  78     int j;
  79 #endif
  80
  81     if (ret == NULL)
  82         return NULL;
  83
  84     ret->references = 1;
  85     ret->key = &ret->pkeys[cert->key - cert->pkeys];
  86     ret->lock = CRYPTO_THREAD_lock_new();
  87     if (ret->lock == NULL) {
  88         ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
  89         OPENSSL_free(ret);
  90         return NULL;
  91     }
  92
  93     if (cert->dh_tmp != NULL) {
  94         ret->dh_tmp = cert->dh_tmp;
  95         EVP_PKEY_up_ref(ret->dh_tmp);
  96     }
  97
  98     ret->dh_tmp_cb = cert->dh_tmp_cb;
  99     ret->dh_tmp_auto = cert->dh_tmp_auto;
 100
 101     for (i = 0; i < SSL_PKEY_NUM; i++) {
 102         CERT_PKEY *cpk = cert->pkeys + i;
 103         CERT_PKEY *rpk = ret->pkeys + i;
 104
 105         if (cpk->x509 != NULL) {
 106             rpk->x509 = cpk->x509;
 107             X509_up_ref(rpk->x509);
 108         }
 109
 110         if (cpk->privatekey != NULL) {
 111             rpk->privatekey = cpk->privatekey;
 112             EVP_PKEY_up_ref(cpk->privatekey);
 113         }
 114
 115         if (cpk->chain) {
 116             rpk->chain = X509_chain_up_ref(cpk->chain);
 117             if (!rpk->chain) {
 118                 ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 119                 goto err;
 120             }
 121         }
 122         if (cpk->serverinfo != NULL) {
 123             /* Just copy everything. */
 124             rpk->serverinfo = OPENSSL_memdup(cpk->serverinfo, cpk->serverinfo_length);
 125             if (rpk->serverinfo == NULL)
 126                 goto err;
 127             rpk->serverinfo_length = cpk->serverinfo_length;
 128         }
 129 #ifndef OPENSSL_NO_COMP_ALG
 130         for (j = TLSEXT_comp_cert_none; j < TLSEXT_comp_cert_limit; j++) {
 131             if (cpk->comp_cert[j] != NULL) {
 132                 if (!OSSL_COMP_CERT_up_ref(cpk->comp_cert[j]))
 133                     goto err;
 134                 rpk->comp_cert[j] = cpk->comp_cert[j];
 135             }
 136         }
 137 #endif
 138     }
 139
 140     /* Configured sigalgs copied across */
 141     if (cert->conf_sigalgs) {
 142         ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen
 143                                            * sizeof(*cert->conf_sigalgs));
 144         if (ret->conf_sigalgs == NULL)
 145             goto err;
 146         memcpy(ret->conf_sigalgs, cert->conf_sigalgs,
 147                cert->conf_sigalgslen * sizeof(*cert->conf_sigalgs));
 148         ret->conf_sigalgslen = cert->conf_sigalgslen;
 149     } else
 150         ret->conf_sigalgs = NULL;
 151
 152     if (cert->client_sigalgs) {
 153         ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen
 154                                              * sizeof(*cert->client_sigalgs));
 155         if (ret->client_sigalgs == NULL)
 156             goto err;
 157         memcpy(ret->client_sigalgs, cert->client_sigalgs,
 158                cert->client_sigalgslen * sizeof(*cert->client_sigalgs));
 159         ret->client_sigalgslen = cert->client_sigalgslen;
 160     } else
 161         ret->client_sigalgs = NULL;
 162     /* Copy any custom client certificate types */
 163     if (cert->ctype) {
 164         ret->ctype = OPENSSL_memdup(cert->ctype, cert->ctype_len);
 165         if (ret->ctype == NULL)
 166             goto err;
 167         ret->ctype_len = cert->ctype_len;
 168     }
 169
 170     ret->cert_flags = cert->cert_flags;
 171
 172     ret->cert_cb = cert->cert_cb;
 173     ret->cert_cb_arg = cert->cert_cb_arg;
 174
 175     if (cert->verify_store) {
 176         X509_STORE_up_ref(cert->verify_store);
 177         ret->verify_store = cert->verify_store;
 178     }
 179
 180     if (cert->chain_store) {
 181         X509_STORE_up_ref(cert->chain_store);
 182         ret->chain_store = cert->chain_store;
 183     }
 184
 185     ret->sec_cb = cert->sec_cb;
 186     ret->sec_level = cert->sec_level;
 187     ret->sec_ex = cert->sec_ex;
 188
 189     if (!custom_exts_copy(&ret->custext, &cert->custext))
 190         goto err;
 191 #ifndef OPENSSL_NO_PSK
 192     if (cert->psk_identity_hint) {
 193         ret->psk_identity_hint = OPENSSL_strdup(cert->psk_identity_hint);
 194         if (ret->psk_identity_hint == NULL)
 195             goto err;
 196     }
 197 #endif
 198     return ret;
 199
 200  err:
 201     ssl_cert_free(ret);
 202
 203     return NULL;
 204 }
 205
 206 /* Free up and clear all certificates and chains */
 207
 208 void ssl_cert_clear_certs(CERT *c)
 209 {
 210     int i;
 211 #ifndef OPENSSL_NO_COMP_ALG
 212     int j;
 213 #endif
 214
 215     if (c == NULL)
 216         return;
 217     for (i = 0; i < SSL_PKEY_NUM; i++) {
 218         CERT_PKEY *cpk = c->pkeys + i;
 219         X509_free(cpk->x509);
 220         cpk->x509 = NULL;
 221         EVP_PKEY_free(cpk->privatekey);
 222         cpk->privatekey = NULL;
 223         OSSL_STACK_OF_X509_free(cpk->chain);
 224         cpk->chain = NULL;
 225         OPENSSL_free(cpk->serverinfo);
 226         cpk->serverinfo = NULL;
 227         cpk->serverinfo_length = 0;
 228 #ifndef OPENSSL_NO_COMP_ALG
 229         for (j = 0; j < TLSEXT_comp_cert_limit; j++) {
 230             OSSL_COMP_CERT_free(cpk->comp_cert[j]);
 231             cpk->comp_cert[j] = NULL;
 232             cpk->cert_comp_used = 0;
 233         }
 234 #endif
 235     }
 236 }
 237
 238 void ssl_cert_free(CERT *c)
 239 {
 240     int i;
 241
 242     if (c == NULL)
 243         return;
 244     CRYPTO_DOWN_REF(&c->references, &i, c->lock);
 245     REF_PRINT_COUNT("CERT", c);
 246     if (i > 0)
 247         return;
 248     REF_ASSERT_ISNT(i < 0);
 249
 250     EVP_PKEY_free(c->dh_tmp);
 251
 252     ssl_cert_clear_certs(c);
 253     OPENSSL_free(c->conf_sigalgs);
 254     OPENSSL_free(c->client_sigalgs);
 255     OPENSSL_free(c->ctype);
 256     X509_STORE_free(c->verify_store);
 257     X509_STORE_free(c->chain_store);
 258     custom_exts_free(&c->custext);
 259 #ifndef OPENSSL_NO_PSK
 260     OPENSSL_free(c->psk_identity_hint);
 261 #endif
 262     CRYPTO_THREAD_lock_free(c->lock);
 263     OPENSSL_free(c);
 264 }
 265
 266 int ssl_cert_set0_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
 267 {
 268     int i, r;
 269     CERT_PKEY *cpk = s != NULL ? s->cert->key : ctx->cert->key;
 270
 271     if (!cpk)
 272         return 0;
 273     for (i = 0; i < sk_X509_num(chain); i++) {
 274         X509 *x = sk_X509_value(chain, i);
 275
 276         r = ssl_security_cert(s, ctx, x, 0, 0);
 277         if (r != 1) {
 278             ERR_raise(ERR_LIB_SSL, r);
 279             return 0;
 280         }
 281     }
 282     OSSL_STACK_OF_X509_free(cpk->chain);
 283     cpk->chain = chain;
 284     return 1;
 285 }
 286
 287 int ssl_cert_set1_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
 288 {
 289     STACK_OF(X509) *dchain;
 290     if (!chain)
 291         return ssl_cert_set0_chain(s, ctx, NULL);
 292     dchain = X509_chain_up_ref(chain);
 293     if (!dchain)
 294         return 0;
 295     if (!ssl_cert_set0_chain(s, ctx, dchain)) {
 296         OSSL_STACK_OF_X509_free(dchain);
 297         return 0;
 298     }
 299     return 1;
 300 }
 301
 302 int ssl_cert_add0_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x)
 303 {
 304     int r;
 305     CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
 306     if (!cpk)
 307         return 0;
 308     r = ssl_security_cert(s, ctx, x, 0, 0);
 309     if (r != 1) {
 310         ERR_raise(ERR_LIB_SSL, r);
 311         return 0;
 312     }
 313     if (!cpk->chain)
 314         cpk->chain = sk_X509_new_null();
 315     if (!cpk->chain || !sk_X509_push(cpk->chain, x))
 316         return 0;
 317     return 1;
 318 }
 319
 320 int ssl_cert_add1_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x)
 321 {
 322     if (!ssl_cert_add0_chain_cert(s, ctx, x))
 323         return 0;
 324     X509_up_ref(x);
 325     return 1;
 326 }
 327
 328 int ssl_cert_select_current(CERT *c, X509 *x)
 329 {
 330     int i;
 331     if (x == NULL)
 332         return 0;
 333     for (i = 0; i < SSL_PKEY_NUM; i++) {
 334         CERT_PKEY *cpk = c->pkeys + i;
 335         if (cpk->x509 == x && cpk->privatekey) {
 336             c->key = cpk;
 337             return 1;
 338         }
 339     }
 340
 341     for (i = 0; i < SSL_PKEY_NUM; i++) {
 342         CERT_PKEY *cpk = c->pkeys + i;
 343         if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) {
 344             c->key = cpk;
 345             return 1;
 346         }
 347     }
 348     return 0;
 349 }
 350
 351 int ssl_cert_set_current(CERT *c, long op)
 352 {
 353     int i, idx;
 354     if (!c)
 355         return 0;
 356     if (op == SSL_CERT_SET_FIRST)
 357         idx = 0;
 358     else if (op == SSL_CERT_SET_NEXT) {
 359         idx = (int)(c->key - c->pkeys + 1);
 360         if (idx >= SSL_PKEY_NUM)
 361             return 0;
 362     } else
 363         return 0;
 364     for (i = idx; i < SSL_PKEY_NUM; i++) {
 365         CERT_PKEY *cpk = c->pkeys + i;
 366         if (cpk->x509 && cpk->privatekey) {
 367             c->key = cpk;
 368             return 1;
 369         }
 370     }
 371     return 0;
 372 }
 373
 374 void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg)
 375 {
 376     c->cert_cb = cb;
 377     c->cert_cb_arg = arg;
 378 }
 379
 380 /*
 381  * Verify a certificate chain
 382  * Return codes:
 383  *  1: Verify success
 384  *  0: Verify failure or error
 385  * -1: Retry required
 386  */
 387 int ssl_verify_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk)
 388 {
 389     X509 *x;
 390     int i = 0;
 391     X509_STORE *verify_store;
 392     X509_STORE_CTX *ctx = NULL;
 393     X509_VERIFY_PARAM *param;
 394     SSL_CTX *sctx;
 395
 396     if ((sk == NULL) || (sk_X509_num(sk) == 0))
 397         return 0;
 398
 399     sctx = SSL_CONNECTION_GET_CTX(s);
 400     if (s->cert->verify_store)
 401         verify_store = s->cert->verify_store;
 402     else
 403         verify_store = sctx->cert_store;
 404
 405     ctx = X509_STORE_CTX_new_ex(sctx->libctx, sctx->propq);
 406     if (ctx == NULL) {
 407         ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 408         return 0;
 409     }
 410
 411     x = sk_X509_value(sk, 0);
 412     if (!X509_STORE_CTX_init(ctx, verify_store, x, sk)) {
 413         ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 414         goto end;
 415     }
 416     param = X509_STORE_CTX_get0_param(ctx);
 417     /*
 418      * XXX: Separate @AUTHSECLEVEL and @TLSSECLEVEL would be useful at some
 419      * point, for now a single @SECLEVEL sets the same policy for TLS crypto
 420      * and PKI authentication.
 421      */
 422     X509_VERIFY_PARAM_set_auth_level(param,
 423         SSL_get_security_level(SSL_CONNECTION_GET_SSL(s)));
 424
 425     /* Set suite B flags if needed */
 426     X509_STORE_CTX_set_flags(ctx, tls1_suiteb(s));
 427     if (!X509_STORE_CTX_set_ex_data(ctx,
 428             SSL_get_ex_data_X509_STORE_CTX_idx(), s)) {
 429         goto end;
 430     }
 431
 432     /* Verify via DANE if enabled */
 433     if (DANETLS_ENABLED(&s->dane))
 434         X509_STORE_CTX_set0_dane(ctx, &s->dane);
 435
 436     /*
 437      * We need to inherit the verify parameters. These can be determined by
 438      * the context: if its a server it will verify SSL client certificates or
 439      * vice versa.
 440      */
 441
 442     X509_STORE_CTX_set_default(ctx, s->server ? "ssl_client" : "ssl_server");
 443     /*
 444      * Anything non-default in "s->param" should overwrite anything in the ctx.
 445      */
 446     X509_VERIFY_PARAM_set1(param, s->param);
 447
 448     if (s->verify_callback)
 449         X509_STORE_CTX_set_verify_cb(ctx, s->verify_callback);
 450
 451     if (sctx->app_verify_callback != NULL) {
 452         i = sctx->app_verify_callback(ctx, sctx->app_verify_arg);
 453     } else {
 454         i = X509_verify_cert(ctx);
 455         /* We treat an error in the same way as a failure to verify */
 456         if (i < 0)
 457             i = 0;
 458     }
 459
 460     s->verify_result = X509_STORE_CTX_get_error(ctx);
 461     OSSL_STACK_OF_X509_free(s->verified_chain);
 462     s->verified_chain = NULL;
 463     if (X509_STORE_CTX_get0_chain(ctx) != NULL) {
 464         s->verified_chain = X509_STORE_CTX_get1_chain(ctx);
 465         if (s->verified_chain == NULL) {
 466             ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 467             i = 0;
 468         }
 469     }
 470
 471     /* Move peername from the store context params to the SSL handle's */
 472     X509_VERIFY_PARAM_move_peername(s->param, param);
 473
 474  end:
 475     X509_STORE_CTX_free(ctx);
 476     return i;
 477 }
 478
 479 static void set0_CA_list(STACK_OF(X509_NAME) **ca_list,
 480                         STACK_OF(X509_NAME) *name_list)
 481 {
 482     sk_X509_NAME_pop_free(*ca_list, X509_NAME_free);
 483     *ca_list = name_list;
 484 }
 485
 486 STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk)
 487 {
 488     int i;
 489     const int num = sk_X509_NAME_num(sk);
 490     STACK_OF(X509_NAME) *ret;
 491     X509_NAME *name;
 492
 493     ret = sk_X509_NAME_new_reserve(NULL, num);
 494     if (ret == NULL) {
 495         ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
 496         return NULL;
 497     }
 498     for (i = 0; i < num; i++) {
 499         name = X509_NAME_dup(sk_X509_NAME_value(sk, i));
 500         if (name == NULL) {
 501             ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 502             sk_X509_NAME_pop_free(ret, X509_NAME_free);
 503             return NULL;
 504         }
 505         sk_X509_NAME_push(ret, name);   /* Cannot fail after reserve call */
 506     }
 507     return ret;
 508 }
 509
 510 void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
 511 {
 512     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 513
 514     if (sc == NULL)
 515         return;
 516
 517     set0_CA_list(&sc->ca_names, name_list);
 518 }
 519
 520 void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
 521 {
 522     set0_CA_list(&ctx->ca_names, name_list);
 523 }
 524
 525 const STACK_OF(X509_NAME) *SSL_CTX_get0_CA_list(const SSL_CTX *ctx)
 526 {
 527     return ctx->ca_names;
 528 }
 529
 530 const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s)
 531 {
 532     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 533
 534     if (sc == NULL)
 535         return NULL;
 536
 537     return sc->ca_names != NULL ? sc->ca_names : s->ctx->ca_names;
 538 }
 539
 540 void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
 541 {
 542     set0_CA_list(&ctx->client_ca_names, name_list);
 543 }
 544
 545 STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx)
 546 {
 547     return ctx->client_ca_names;
 548 }
 549
 550 void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
 551 {
 552     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 553
 554     if (sc == NULL)
 555         return;
 556
 557     set0_CA_list(&sc->client_ca_names, name_list);
 558 }
 559
 560 const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s)
 561 {
 562     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 563
 564     if (sc == NULL)
 565         return NULL;
 566
 567     return sc->s3.tmp.peer_ca_names;
 568 }
 569
 570 STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s)
 571 {
 572     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 573
 574     if (sc == NULL)
 575         return NULL;
 576
 577     if (!sc->server)
 578         return sc->s3.tmp.peer_ca_names;
 579     return sc->client_ca_names != NULL ? sc->client_ca_names
 580                                        : s->ctx->client_ca_names;
 581 }
 582
 583 static int add_ca_name(STACK_OF(X509_NAME) **sk, const X509 *x)
 584 {
 585     X509_NAME *name;
 586
 587     if (x == NULL)
 588         return 0;
 589     if (*sk == NULL && ((*sk = sk_X509_NAME_new_null()) == NULL))
 590         return 0;
 591
 592     if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL)
 593         return 0;
 594
 595     if (!sk_X509_NAME_push(*sk, name)) {
 596         X509_NAME_free(name);
 597         return 0;
 598     }
 599     return 1;
 600 }
 601
 602 int SSL_add1_to_CA_list(SSL *ssl, const X509 *x)
 603 {
 604     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
 605
 606     if (sc == NULL)
 607         return 0;
 608
 609     return add_ca_name(&sc->ca_names, x);
 610 }
 611
 612 int SSL_CTX_add1_to_CA_list(SSL_CTX *ctx, const X509 *x)
 613 {
 614     return add_ca_name(&ctx->ca_names, x);
 615 }
 616
 617 /*
 618  * The following two are older names are to be replaced with
 619  * SSL(_CTX)_add1_to_CA_list
 620  */
 621 int SSL_add_client_CA(SSL *ssl, X509 *x)
 622 {
 623     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
 624
 625     if (sc == NULL)
 626         return 0;
 627
 628     return add_ca_name(&sc->client_ca_names, x);
 629 }
 630
 631 int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x)
 632 {
 633     return add_ca_name(&ctx->client_ca_names, x);
 634 }
 635
 636 static int xname_cmp(const X509_NAME *a, const X509_NAME *b)
 637 {
 638     unsigned char *abuf = NULL, *bbuf = NULL;
 639     int alen, blen, ret;
 640
 641     /* X509_NAME_cmp() itself casts away constness in this way, so
 642      * assume it's safe:
 643      */
 644     alen = i2d_X509_NAME((X509_NAME *)a, &abuf);
 645     blen = i2d_X509_NAME((X509_NAME *)b, &bbuf);
 646
 647     if (alen < 0 || blen < 0)
 648         ret = -2;
 649     else if (alen != blen)
 650         ret = alen - blen;
 651     else /* alen == blen */
 652         ret = memcmp(abuf, bbuf, alen);
 653
 654     OPENSSL_free(abuf);
 655     OPENSSL_free(bbuf);
 656
 657     return ret;
 658 }
 659
 660 static int xname_sk_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
 661 {
 662     return xname_cmp(*a, *b);
 663 }
 664
 665 static unsigned long xname_hash(const X509_NAME *a)
 666 {
 667     /* This returns 0 also if SHA1 is not available */
 668     return X509_NAME_hash_ex((X509_NAME *)a, NULL, NULL, NULL);
 669 }
 670
 671 STACK_OF(X509_NAME) *SSL_load_client_CA_file_ex(const char *file,
 672                                                 OSSL_LIB_CTX *libctx,
 673                                                 const char *propq)
 674 {
 675     BIO *in = BIO_new(BIO_s_file());
 676     X509 *x = NULL;
 677     X509_NAME *xn = NULL;
 678     STACK_OF(X509_NAME) *ret = NULL;
 679     LHASH_OF(X509_NAME) *name_hash = lh_X509_NAME_new(xname_hash, xname_cmp);
 680     OSSL_LIB_CTX *prev_libctx = NULL;
 681
 682     if (name_hash == NULL) {
 683         ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
 684         goto err;
 685     }
 686     if (in == NULL) {
 687         ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB);
 688         goto err;
 689     }
 690
 691     x = X509_new_ex(libctx, propq);
 692     if (x == NULL) {
 693         ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 694         goto err;
 695     }
 696     if (BIO_read_filename(in, file) <= 0)
 697         goto err;
 698
 699     /* Internally lh_X509_NAME_retrieve() needs the libctx to retrieve SHA1 */
 700     prev_libctx = OSSL_LIB_CTX_set0_default(libctx);
 701     for (;;) {
 702         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
 703             break;
 704         if (ret == NULL) {
 705             ret = sk_X509_NAME_new_null();
 706             if (ret == NULL) {
 707                 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
 708                 goto err;
 709             }
 710         }
 711         if ((xn = X509_get_subject_name(x)) == NULL)
 712             goto err;
 713         /* check for duplicates */
 714         xn = X509_NAME_dup(xn);
 715         if (xn == NULL)
 716             goto err;
 717         if (lh_X509_NAME_retrieve(name_hash, xn) != NULL) {
 718             /* Duplicate. */
 719             X509_NAME_free(xn);
 720             xn = NULL;
 721         } else {
 722             lh_X509_NAME_insert(name_hash, xn);
 723             if (!sk_X509_NAME_push(ret, xn))
 724                 goto err;
 725         }
 726     }
 727     goto done;
 728
 729  err:
 730     X509_NAME_free(xn);
 731     sk_X509_NAME_pop_free(ret, X509_NAME_free);
 732     ret = NULL;
 733  done:
 734     /* restore the old libctx */
 735     OSSL_LIB_CTX_set0_default(prev_libctx);
 736     BIO_free(in);
 737     X509_free(x);
 738     lh_X509_NAME_free(name_hash);
 739     if (ret != NULL)
 740         ERR_clear_error();
 741     return ret;
 742 }
 743
 744 STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file)
 745 {
 746     return SSL_load_client_CA_file_ex(file, NULL, NULL);
 747 }
 748
 749 int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
 750                                         const char *file)
 751 {
 752     BIO *in;
 753     X509 *x = NULL;
 754     X509_NAME *xn = NULL;
 755     int ret = 1;
 756     int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b);
 757
 758     oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp);
 759
 760     in = BIO_new(BIO_s_file());
 761
 762     if (in == NULL) {
 763         ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB);
 764         goto err;
 765     }
 766
 767     if (BIO_read_filename(in, file) <= 0)
 768         goto err;
 769
 770     for (;;) {
 771         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
 772             break;
 773         if ((xn = X509_get_subject_name(x)) == NULL)
 774             goto err;
 775         xn = X509_NAME_dup(xn);
 776         if (xn == NULL)
 777             goto err;
 778         if (sk_X509_NAME_find(stack, xn) >= 0) {
 779             /* Duplicate. */
 780             X509_NAME_free(xn);
 781         } else if (!sk_X509_NAME_push(stack, xn)) {
 782             X509_NAME_free(xn);
 783             goto err;
 784         }
 785     }
 786
 787     ERR_clear_error();
 788     goto done;
 789
 790  err:
 791     ret = 0;
 792  done:
 793     BIO_free(in);
 794     X509_free(x);
 795     (void)sk_X509_NAME_set_cmp_func(stack, oldcmp);
 796     return ret;
 797 }
 798
 799 int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
 800                                        const char *dir)
 801 {
 802     OPENSSL_DIR_CTX *d = NULL;
 803     const char *filename;
 804     int ret = 0;
 805
 806     /* Note that a side effect is that the CAs will be sorted by name */
 807
 808     while ((filename = OPENSSL_DIR_read(&d, dir))) {
 809         char buf[1024];
 810         int r;
 811
 812         if (strlen(dir) + strlen(filename) + 2 > sizeof(buf)) {
 813             ERR_raise(ERR_LIB_SSL, SSL_R_PATH_TOO_LONG);
 814             goto err;
 815         }
 816 #ifdef OPENSSL_SYS_VMS
 817         r = BIO_snprintf(buf, sizeof(buf), "%s%s", dir, filename);
 818 #else
 819         r = BIO_snprintf(buf, sizeof(buf), "%s/%s", dir, filename);
 820 #endif
 821         if (r <= 0 || r >= (int)sizeof(buf))
 822             goto err;
 823         if (!SSL_add_file_cert_subjects_to_stack(stack, buf))
 824             goto err;
 825     }
 826
 827     if (errno) {
 828         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
 829                        "calling OPENSSL_dir_read(%s)", dir);
 830         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
 831         goto err;
 832     }
 833
 834     ret = 1;
 835
 836  err:
 837     if (d)
 838         OPENSSL_DIR_end(&d);
 839
 840     return ret;
 841 }
 842
 843 static int add_uris_recursive(STACK_OF(X509_NAME) *stack,
 844                               const char *uri, int depth)
 845 {
 846     int ok = 1;
 847     OSSL_STORE_CTX *ctx = NULL;
 848     X509 *x = NULL;
 849     X509_NAME *xn = NULL;
 850
 851     if ((ctx = OSSL_STORE_open(uri, NULL, NULL, NULL, NULL)) == NULL)
 852         goto err;
 853
 854     while (!OSSL_STORE_eof(ctx) && !OSSL_STORE_error(ctx)) {
 855         OSSL_STORE_INFO *info = OSSL_STORE_load(ctx);
 856         int infotype = info == 0 ? 0 : OSSL_STORE_INFO_get_type(info);
 857
 858         if (info == NULL)
 859             continue;
 860
 861         if (infotype == OSSL_STORE_INFO_NAME) {
 862             /*
 863              * This is an entry in the "directory" represented by the current
 864              * uri.  if |depth| allows, dive into it.
 865              */
 866             if (depth > 0)
 867                 ok = add_uris_recursive(stack, OSSL_STORE_INFO_get0_NAME(info),
 868                                         depth - 1);
 869         } else if (infotype == OSSL_STORE_INFO_CERT) {
 870             if ((x = OSSL_STORE_INFO_get0_CERT(info)) == NULL
 871                 || (xn = X509_get_subject_name(x)) == NULL
 872                 || (xn = X509_NAME_dup(xn)) == NULL)
 873                 goto err;
 874             if (sk_X509_NAME_find(stack, xn) >= 0) {
 875                 /* Duplicate. */
 876                 X509_NAME_free(xn);
 877             } else if (!sk_X509_NAME_push(stack, xn)) {
 878                 X509_NAME_free(xn);
 879                 goto err;
 880             }
 881         }
 882
 883         OSSL_STORE_INFO_free(info);
 884     }
 885
 886     ERR_clear_error();
 887     goto done;
 888
 889  err:
 890     ok = 0;
 891  done:
 892     OSSL_STORE_close(ctx);
 893
 894     return ok;
 895 }
 896
 897 int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
 898                                          const char *store)
 899 {
 900     int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b)
 901         = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp);
 902     int ret = add_uris_recursive(stack, store, 1);
 903
 904     (void)sk_X509_NAME_set_cmp_func(stack, oldcmp);
 905     return ret;
 906 }
 907
 908 /* Build a certificate chain for current certificate */
 909 int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags)
 910 {
 911     CERT *c = s != NULL ? s->cert : ctx->cert;
 912     CERT_PKEY *cpk = c->key;
 913     X509_STORE *chain_store = NULL;
 914     X509_STORE_CTX *xs_ctx = NULL;
 915     STACK_OF(X509) *chain = NULL, *untrusted = NULL;
 916     X509 *x;
 917     SSL_CTX *real_ctx = (s == NULL) ? ctx : SSL_CONNECTION_GET_CTX(s);
 918     int i, rv = 0;
 919
 920     if (cpk->x509 == NULL) {
 921         ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_SET);
 922         goto err;
 923     }
 924     /* Rearranging and check the chain: add everything to a store */
 925     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) {
 926         chain_store = X509_STORE_new();
 927         if (chain_store == NULL)
 928             goto err;
 929         for (i = 0; i < sk_X509_num(cpk->chain); i++) {
 930             x = sk_X509_value(cpk->chain, i);
 931             if (!X509_STORE_add_cert(chain_store, x))
 932                 goto err;
 933         }
 934         /* Add EE cert too: it might be self signed */
 935         if (!X509_STORE_add_cert(chain_store, cpk->x509))
 936             goto err;
 937     } else {
 938         if (c->chain_store != NULL)
 939             chain_store = c->chain_store;
 940         else
 941             chain_store = real_ctx->cert_store;
 942
 943         if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED)
 944             untrusted = cpk->chain;
 945     }
 946
 947     xs_ctx = X509_STORE_CTX_new_ex(real_ctx->libctx, real_ctx->propq);
 948     if (xs_ctx == NULL) {
 949         ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 950         goto err;
 951     }
 952     if (!X509_STORE_CTX_init(xs_ctx, chain_store, cpk->x509, untrusted)) {
 953         ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
 954         goto err;
 955     }
 956     /* Set suite B flags if needed */
 957     X509_STORE_CTX_set_flags(xs_ctx,
 958                              c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS);
 959
 960     i = X509_verify_cert(xs_ctx);
 961     if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) {
 962         if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR)
 963             ERR_clear_error();
 964         i = 1;
 965         rv = 2;
 966     }
 967     if (i > 0)
 968         chain = X509_STORE_CTX_get1_chain(xs_ctx);
 969     if (i <= 0) {
 970         i = X509_STORE_CTX_get_error(xs_ctx);
 971         ERR_raise_data(ERR_LIB_SSL, SSL_R_CERTIFICATE_VERIFY_FAILED,
 972                        "Verify error:%s", X509_verify_cert_error_string(i));
 973
 974         goto err;
 975     }
 976     /* Remove EE certificate from chain */
 977     x = sk_X509_shift(chain);
 978     X509_free(x);
 979     if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) {
 980         if (sk_X509_num(chain) > 0) {
 981             /* See if last cert is self signed */
 982             x = sk_X509_value(chain, sk_X509_num(chain) - 1);
 983             if (X509_get_extension_flags(x) & EXFLAG_SS) {
 984                 x = sk_X509_pop(chain);
 985                 X509_free(x);
 986             }
 987         }
 988     }
 989     /*
 990      * Check security level of all CA certificates: EE will have been checked
 991      * already.
 992      */
 993     for (i = 0; i < sk_X509_num(chain); i++) {
 994         x = sk_X509_value(chain, i);
 995         rv = ssl_security_cert(s, ctx, x, 0, 0);
 996         if (rv != 1) {
 997             ERR_raise(ERR_LIB_SSL, rv);
 998             OSSL_STACK_OF_X509_free(chain);
 999             rv = 0;
1000             goto err;
1001         }
1002     }
1003     OSSL_STACK_OF_X509_free(cpk->chain);
1004     cpk->chain = chain;
1005     if (rv == 0)
1006         rv = 1;
1007  err:
1008     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK)
1009         X509_STORE_free(chain_store);
1010     X509_STORE_CTX_free(xs_ctx);
1011
1012     return rv;
1013 }
1014
1015 int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref)
1016 {
1017     X509_STORE **pstore;
1018     if (chain)
1019         pstore = &c->chain_store;
1020     else
1021         pstore = &c->verify_store;
1022     X509_STORE_free(*pstore);
1023     *pstore = store;
1024     if (ref && store)
1025         X509_STORE_up_ref(store);
1026     return 1;
1027 }
1028
1029 int ssl_cert_get_cert_store(CERT *c, X509_STORE **pstore, int chain)
1030 {
1031     *pstore = (chain ? c->chain_store : c->verify_store);
1032     return 1;
1033 }
1034
1035 int ssl_get_security_level_bits(const SSL *s, const SSL_CTX *ctx, int *levelp)
1036 {
1037     int level;
1038     /*
1039      * note that there's a corresponding minbits_table
1040      * in crypto/x509/x509_vfy.c that's used for checking the security level
1041      * of RSA and DSA keys
1042      */
1043     static const int minbits_table[5 + 1] = { 0, 80, 112, 128, 192, 256 };
1044
1045     if (ctx != NULL)
1046         level = SSL_CTX_get_security_level(ctx);
1047     else
1048         level = SSL_get_security_level(s);
1049
1050     if (level > 5)
1051         level = 5;
1052     else if (level < 0)
1053         level = 0;
1054
1055     if (levelp != NULL)
1056         *levelp = level;
1057
1058     return minbits_table[level];
1059 }
1060
1061 static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
1062                                          int op, int bits, int nid, void *other,
1063                                          void *ex)
1064 {
1065     int level, minbits, pfs_mask;
1066     const SSL_CONNECTION *sc;
1067
1068     minbits = ssl_get_security_level_bits(s, ctx, &level);
1069
1070     if (level == 0) {
1071         /*
1072          * No EDH keys weaker than 1024-bits even at level 0, otherwise,
1073          * anything goes.
1074          */
1075         if (op == SSL_SECOP_TMP_DH && bits < 80)
1076             return 0;
1077         return 1;
1078     }
1079     switch (op) {
1080     case SSL_SECOP_CIPHER_SUPPORTED:
1081     case SSL_SECOP_CIPHER_SHARED:
1082     case SSL_SECOP_CIPHER_CHECK:
1083         {
1084             const SSL_CIPHER *c = other;
1085             /* No ciphers below security level */
1086             if (bits < minbits)
1087                 return 0;
1088             /* No unauthenticated ciphersuites */
1089             if (c->algorithm_auth & SSL_aNULL)
1090                 return 0;
1091             /* No MD5 mac ciphersuites */
1092             if (c->algorithm_mac & SSL_MD5)
1093                 return 0;
1094             /* SHA1 HMAC is 160 bits of security */
1095             if (minbits > 160 && c->algorithm_mac & SSL_SHA1)
1096                 return 0;
1097             /* Level 3: forward secure ciphersuites only */
1098             pfs_mask = SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK;
1099             if (level >= 3 && c->min_tls != TLS1_3_VERSION &&
1100                                !(c->algorithm_mkey & pfs_mask))
1101                 return 0;
1102             break;
1103         }
1104     case SSL_SECOP_VERSION:
1105         if ((sc = SSL_CONNECTION_FROM_CONST_SSL(s)) == NULL)
1106             return 0;
1107         if (!SSL_CONNECTION_IS_DTLS(sc)) {
1108             /* SSLv3, TLS v1.0 and TLS v1.1 only allowed at level 0 */
1109             if (nid <= TLS1_1_VERSION && level > 0)
1110                 return 0;
1111         } else {
1112             /* DTLS v1.0 only allowed at level 0 */
1113             if (DTLS_VERSION_LT(nid, DTLS1_2_VERSION) && level > 0)
1114                 return 0;
1115         }
1116         break;
1117
1118     case SSL_SECOP_COMPRESSION:
1119         if (level >= 2)
1120             return 0;
1121         break;
1122     case SSL_SECOP_TICKET:
1123         if (level >= 3)
1124             return 0;
1125         break;
1126     default:
1127         if (bits < minbits)
1128             return 0;
1129     }
1130     return 1;
1131 }
1132
1133 int ssl_security(const SSL_CONNECTION *s, int op, int bits, int nid, void *other)
1134 {
1135     return s->cert->sec_cb(SSL_CONNECTION_GET_SSL(s), NULL, op, bits, nid,
1136                            other, s->cert->sec_ex);
1137 }
1138
1139 int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid, void *other)
1140 {
1141     return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other,
1142                              ctx->cert->sec_ex);
1143 }
1144
1145 int ssl_cert_lookup_by_nid(int nid, size_t *pidx)
1146 {
1147     size_t i;
1148
1149     for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) {
1150         if (ssl_cert_info[i].nid == nid) {
1151             *pidx = i;
1152             return 1;
1153         }
1154     }
1155
1156     return 0;
1157 }
1158
1159 const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk, size_t *pidx)
1160 {
1161     size_t i;
1162
1163     for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) {
1164         const SSL_CERT_LOOKUP *tmp_lu = &ssl_cert_info[i];
1165
1166         if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->nid))
1167             || EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->nid))) {
1168             if (pidx != NULL)
1169                 *pidx = i;
1170             return tmp_lu;
1171         }
1172     }
1173
1174     return NULL;
1175 }
1176
1177 const SSL_CERT_LOOKUP *ssl_cert_lookup_by_idx(size_t idx)
1178 {
1179     if (idx >= OSSL_NELEM(ssl_cert_info))
1180         return NULL;
1181     return &ssl_cert_info[idx];
1182 }