1 /* 2 * ! \file ssl/ssl_cert.c 3 */ 4 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 5 * All rights reserved. 6 * 7 * This package is an SSL implementation written 8 * by Eric Young (eay@cryptsoft.com). 9 * The implementation was written so as to conform with Netscapes SSL. 10 * 11 * This library is free for commercial and non-commercial use as long as 12 * the following conditions are aheared to. The following conditions 13 * apply to all code found in this distribution, be it the RC4, RSA, 14 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 15 * included with this distribution is covered by the same copyright terms 16 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 17 * 18 * Copyright remains Eric Young's, and as such any Copyright notices in 19 * the code are not to be removed. 20 * If this package is used in a product, Eric Young should be given attribution 21 * as the author of the parts of the library used. 22 * This can be in the form of a textual message at program startup or 23 * in documentation (online or textual) provided with the package. 24 * 25 * Redistribution and use in source and binary forms, with or without 26 * modification, are permitted provided that the following conditions 27 * are met: 28 * 1. Redistributions of source code must retain the copyright 29 * notice, this list of conditions and the following disclaimer. 30 * 2. Redistributions in binary form must reproduce the above copyright 31 * notice, this list of conditions and the following disclaimer in the 32 * documentation and/or other materials provided with the distribution. 33 * 3. All advertising materials mentioning features or use of this software 34 * must display the following acknowledgement: 35 * "This product includes cryptographic software written by 36 * Eric Young (eay@cryptsoft.com)" 37 * The word 'cryptographic' can be left out if the rouines from the library 38 * being used are not cryptographic related :-). 39 * 4. If you include any Windows specific code (or a derivative thereof) from 40 * the apps directory (application code) you must include an acknowledgement: 41 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 42 * 43 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 44 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 46 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 47 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 49 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 52 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 53 * SUCH DAMAGE. 54 * 55 * The licence and distribution terms for any publically available version or 56 * derivative of this code cannot be changed. i.e. this code cannot simply be 57 * copied and put under another distribution licence 58 * [including the GNU Public Licence.] 59 */ 60 /* ==================================================================== 61 * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved. 62 * 63 * Redistribution and use in source and binary forms, with or without 64 * modification, are permitted provided that the following conditions 65 * are met: 66 * 67 * 1. Redistributions of source code must retain the above copyright 68 * notice, this list of conditions and the following disclaimer. 69 * 70 * 2. Redistributions in binary form must reproduce the above copyright 71 * notice, this list of conditions and the following disclaimer in 72 * the documentation and/or other materials provided with the 73 * distribution. 74 * 75 * 3. All advertising materials mentioning features or use of this 76 * software must display the following acknowledgment: 77 * "This product includes software developed by the OpenSSL Project 78 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" 79 * 80 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 81 * endorse or promote products derived from this software without 82 * prior written permission. For written permission, please contact 83 * openssl-core@openssl.org. 84 * 85 * 5. Products derived from this software may not be called "OpenSSL" 86 * nor may "OpenSSL" appear in their names without prior written 87 * permission of the OpenSSL Project. 88 * 89 * 6. Redistributions of any form whatsoever must retain the following 90 * acknowledgment: 91 * "This product includes software developed by the OpenSSL Project 92 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" 93 * 94 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 95 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 96 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 97 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 98 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 99 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 100 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 101 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 102 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 103 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 104 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 105 * OF THE POSSIBILITY OF SUCH DAMAGE. 106 * ==================================================================== 107 * 108 * This product includes cryptographic software written by Eric Young 109 * (eay@cryptsoft.com). This product includes software written by Tim 110 * Hudson (tjh@cryptsoft.com). 111 * 112 */ 113 /* ==================================================================== 114 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. 115 * ECC cipher suite support in OpenSSL originally developed by 116 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. 117 */ 118 119 #include <stdio.h> 120 121 #include "e_os.h" 122 #ifndef NO_SYS_TYPES_H 123 # include <sys/types.h> 124 #endif 125 126 #include "o_dir.h" 127 #include <openssl/objects.h> 128 #include <openssl/bio.h> 129 #include <openssl/pem.h> 130 #include <openssl/x509v3.h> 131 #ifndef OPENSSL_NO_DH 132 # include <openssl/dh.h> 133 #endif 134 #include <openssl/bn.h> 135 #include "ssl_locl.h" 136 137 int SSL_get_ex_data_X509_STORE_CTX_idx(void) 138 { 139 static volatile int ssl_x509_store_ctx_idx = -1; 140 int got_write_lock = 0; 141 142 if (((size_t)&ssl_x509_store_ctx_idx & 143 (sizeof(ssl_x509_store_ctx_idx) - 1)) 144 == 0) { /* check alignment, practically always true */ 145 int ret; 146 147 if ((ret = ssl_x509_store_ctx_idx) < 0) { 148 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX); 149 if ((ret = ssl_x509_store_ctx_idx) < 0) { 150 ret = ssl_x509_store_ctx_idx = 151 X509_STORE_CTX_get_ex_new_index(0, 152 "SSL for verify callback", 153 NULL, NULL, NULL); 154 } 155 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX); 156 } 157 158 return ret; 159 } else { /* commonly eliminated */ 160 161 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX); 162 163 if (ssl_x509_store_ctx_idx < 0) { 164 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX); 165 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX); 166 got_write_lock = 1; 167 168 if (ssl_x509_store_ctx_idx < 0) { 169 ssl_x509_store_ctx_idx = 170 X509_STORE_CTX_get_ex_new_index(0, 171 "SSL for verify callback", 172 NULL, NULL, NULL); 173 } 174 } 175 176 if (got_write_lock) 177 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX); 178 else 179 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX); 180 181 return ssl_x509_store_ctx_idx; 182 } 183 } 184 185 void ssl_cert_set_default_md(CERT *cert) 186 { 187 /* Set digest values to defaults */ 188 #ifndef OPENSSL_NO_DSA 189 cert->pkeys[SSL_PKEY_DSA_SIGN].digest = EVP_sha1(); 190 #endif 191 #ifndef OPENSSL_NO_RSA 192 cert->pkeys[SSL_PKEY_RSA_SIGN].digest = EVP_sha1(); 193 cert->pkeys[SSL_PKEY_RSA_ENC].digest = EVP_sha1(); 194 #endif 195 #ifndef OPENSSL_NO_ECDSA 196 cert->pkeys[SSL_PKEY_ECC].digest = EVP_sha1(); 197 #endif 198 } 199 200 CERT *ssl_cert_new(void) 201 { 202 CERT *ret; 203 204 ret = (CERT *)OPENSSL_malloc(sizeof(CERT)); 205 if (ret == NULL) { 206 SSLerr(SSL_F_SSL_CERT_NEW, ERR_R_MALLOC_FAILURE); 207 return (NULL); 208 } 209 memset(ret, 0, sizeof(CERT)); 210 211 ret->key = &(ret->pkeys[SSL_PKEY_RSA_ENC]); 212 ret->references = 1; 213 ssl_cert_set_default_md(ret); 214 return (ret); 215 } 216 217 CERT *ssl_cert_dup(CERT *cert) 218 { 219 CERT *ret; 220 int i; 221 222 ret = (CERT *)OPENSSL_malloc(sizeof(CERT)); 223 if (ret == NULL) { 224 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE); 225 return (NULL); 226 } 227 228 memset(ret, 0, sizeof(CERT)); 229 230 ret->references = 1; 231 ret->key = &ret->pkeys[cert->key - &cert->pkeys[0]]; 232 /* 233 * or ret->key = ret->pkeys + (cert->key - cert->pkeys), if you find that 234 * more readable 235 */ 236 237 ret->valid = cert->valid; 238 ret->mask_k = cert->mask_k; 239 ret->mask_a = cert->mask_a; 240 ret->export_mask_k = cert->export_mask_k; 241 ret->export_mask_a = cert->export_mask_a; 242 243 #ifndef OPENSSL_NO_RSA 244 if (cert->rsa_tmp != NULL) { 245 RSA_up_ref(cert->rsa_tmp); 246 ret->rsa_tmp = cert->rsa_tmp; 247 } 248 ret->rsa_tmp_cb = cert->rsa_tmp_cb; 249 #endif 250 251 #ifndef OPENSSL_NO_DH 252 if (cert->dh_tmp != NULL) { 253 ret->dh_tmp = DHparams_dup(cert->dh_tmp); 254 if (ret->dh_tmp == NULL) { 255 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_DH_LIB); 256 goto err; 257 } 258 if (cert->dh_tmp->priv_key) { 259 BIGNUM *b = BN_dup(cert->dh_tmp->priv_key); 260 if (!b) { 261 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB); 262 goto err; 263 } 264 ret->dh_tmp->priv_key = b; 265 } 266 if (cert->dh_tmp->pub_key) { 267 BIGNUM *b = BN_dup(cert->dh_tmp->pub_key); 268 if (!b) { 269 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB); 270 goto err; 271 } 272 ret->dh_tmp->pub_key = b; 273 } 274 } 275 ret->dh_tmp_cb = cert->dh_tmp_cb; 276 #endif 277 278 #ifndef OPENSSL_NO_ECDH 279 if (cert->ecdh_tmp) { 280 ret->ecdh_tmp = EC_KEY_dup(cert->ecdh_tmp); 281 if (ret->ecdh_tmp == NULL) { 282 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_EC_LIB); 283 goto err; 284 } 285 } 286 ret->ecdh_tmp_cb = cert->ecdh_tmp_cb; 287 ret->ecdh_tmp_auto = cert->ecdh_tmp_auto; 288 #endif 289 290 for (i = 0; i < SSL_PKEY_NUM; i++) { 291 CERT_PKEY *cpk = cert->pkeys + i; 292 CERT_PKEY *rpk = ret->pkeys + i; 293 if (cpk->x509 != NULL) { 294 rpk->x509 = cpk->x509; 295 CRYPTO_add(&rpk->x509->references, 1, CRYPTO_LOCK_X509); 296 } 297 298 if (cpk->privatekey != NULL) { 299 rpk->privatekey = cpk->privatekey; 300 CRYPTO_add(&cpk->privatekey->references, 1, CRYPTO_LOCK_EVP_PKEY); 301 } 302 303 if (cpk->chain) { 304 rpk->chain = X509_chain_up_ref(cpk->chain); 305 if (!rpk->chain) { 306 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE); 307 goto err; 308 } 309 } 310 rpk->valid_flags = 0; 311 #ifndef OPENSSL_NO_TLSEXT 312 if (cert->pkeys[i].serverinfo != NULL) { 313 /* Just copy everything. */ 314 ret->pkeys[i].serverinfo = 315 OPENSSL_malloc(cert->pkeys[i].serverinfo_length); 316 if (ret->pkeys[i].serverinfo == NULL) { 317 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE); 318 return NULL; 319 } 320 ret->pkeys[i].serverinfo_length = 321 cert->pkeys[i].serverinfo_length; 322 memcpy(ret->pkeys[i].serverinfo, 323 cert->pkeys[i].serverinfo, 324 cert->pkeys[i].serverinfo_length); 325 } 326 #endif 327 } 328 329 /* 330 * Set digests to defaults. NB: we don't copy existing values as they 331 * will be set during handshake. 332 */ 333 ssl_cert_set_default_md(ret); 334 /* Peer sigalgs set to NULL as we get these from handshake too */ 335 ret->peer_sigalgs = NULL; 336 ret->peer_sigalgslen = 0; 337 /* Configured sigalgs however we copy across */ 338 339 if (cert->conf_sigalgs) { 340 ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen); 341 if (!ret->conf_sigalgs) 342 goto err; 343 memcpy(ret->conf_sigalgs, cert->conf_sigalgs, cert->conf_sigalgslen); 344 ret->conf_sigalgslen = cert->conf_sigalgslen; 345 } else 346 ret->conf_sigalgs = NULL; 347 348 if (cert->client_sigalgs) { 349 ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen); 350 if (!ret->client_sigalgs) 351 goto err; 352 memcpy(ret->client_sigalgs, cert->client_sigalgs, 353 cert->client_sigalgslen); 354 ret->client_sigalgslen = cert->client_sigalgslen; 355 } else 356 ret->client_sigalgs = NULL; 357 /* Shared sigalgs also NULL */ 358 ret->shared_sigalgs = NULL; 359 /* Copy any custom client certificate types */ 360 if (cert->ctypes) { 361 ret->ctypes = OPENSSL_malloc(cert->ctype_num); 362 if (!ret->ctypes) 363 goto err; 364 memcpy(ret->ctypes, cert->ctypes, cert->ctype_num); 365 ret->ctype_num = cert->ctype_num; 366 } 367 368 ret->cert_flags = cert->cert_flags; 369 370 ret->cert_cb = cert->cert_cb; 371 ret->cert_cb_arg = cert->cert_cb_arg; 372 373 if (cert->verify_store) { 374 CRYPTO_add(&cert->verify_store->references, 1, 375 CRYPTO_LOCK_X509_STORE); 376 ret->verify_store = cert->verify_store; 377 } 378 379 if (cert->chain_store) { 380 CRYPTO_add(&cert->chain_store->references, 1, CRYPTO_LOCK_X509_STORE); 381 ret->chain_store = cert->chain_store; 382 } 383 384 ret->ciphers_raw = NULL; 385 386 #ifndef OPENSSL_NO_TLSEXT 387 if (!custom_exts_copy(&ret->cli_ext, &cert->cli_ext)) 388 goto err; 389 if (!custom_exts_copy(&ret->srv_ext, &cert->srv_ext)) 390 goto err; 391 #endif 392 393 return (ret); 394 395 #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_ECDH) 396 err: 397 #endif 398 #ifndef OPENSSL_NO_RSA 399 if (ret->rsa_tmp != NULL) 400 RSA_free(ret->rsa_tmp); 401 #endif 402 #ifndef OPENSSL_NO_DH 403 if (ret->dh_tmp != NULL) 404 DH_free(ret->dh_tmp); 405 #endif 406 #ifndef OPENSSL_NO_ECDH 407 if (ret->ecdh_tmp != NULL) 408 EC_KEY_free(ret->ecdh_tmp); 409 #endif 410 411 #ifndef OPENSSL_NO_TLSEXT 412 custom_exts_free(&ret->cli_ext); 413 custom_exts_free(&ret->srv_ext); 414 #endif 415 416 ssl_cert_clear_certs(ret); 417 418 return NULL; 419 } 420 421 /* Free up and clear all certificates and chains */ 422 423 void ssl_cert_clear_certs(CERT *c) 424 { 425 int i; 426 if (c == NULL) 427 return; 428 for (i = 0; i < SSL_PKEY_NUM; i++) { 429 CERT_PKEY *cpk = c->pkeys + i; 430 if (cpk->x509) { 431 X509_free(cpk->x509); 432 cpk->x509 = NULL; 433 } 434 if (cpk->privatekey) { 435 EVP_PKEY_free(cpk->privatekey); 436 cpk->privatekey = NULL; 437 } 438 if (cpk->chain) { 439 sk_X509_pop_free(cpk->chain, X509_free); 440 cpk->chain = NULL; 441 } 442 #ifndef OPENSSL_NO_TLSEXT 443 if (cpk->serverinfo) { 444 OPENSSL_free(cpk->serverinfo); 445 cpk->serverinfo = NULL; 446 cpk->serverinfo_length = 0; 447 } 448 #endif 449 /* Clear all flags apart from explicit sign */ 450 cpk->valid_flags &= CERT_PKEY_EXPLICIT_SIGN; 451 } 452 } 453 454 void ssl_cert_free(CERT *c) 455 { 456 int i; 457 458 if (c == NULL) 459 return; 460 461 i = CRYPTO_add(&c->references, -1, CRYPTO_LOCK_SSL_CERT); 462 #ifdef REF_PRINT 463 REF_PRINT("CERT", c); 464 #endif 465 if (i > 0) 466 return; 467 #ifdef REF_CHECK 468 if (i < 0) { 469 fprintf(stderr, "ssl_cert_free, bad reference count\n"); 470 abort(); /* ok */ 471 } 472 #endif 473 474 #ifndef OPENSSL_NO_RSA 475 if (c->rsa_tmp) 476 RSA_free(c->rsa_tmp); 477 #endif 478 #ifndef OPENSSL_NO_DH 479 if (c->dh_tmp) 480 DH_free(c->dh_tmp); 481 #endif 482 #ifndef OPENSSL_NO_ECDH 483 if (c->ecdh_tmp) 484 EC_KEY_free(c->ecdh_tmp); 485 #endif 486 487 ssl_cert_clear_certs(c); 488 if (c->peer_sigalgs) 489 OPENSSL_free(c->peer_sigalgs); 490 if (c->conf_sigalgs) 491 OPENSSL_free(c->conf_sigalgs); 492 if (c->client_sigalgs) 493 OPENSSL_free(c->client_sigalgs); 494 if (c->shared_sigalgs) 495 OPENSSL_free(c->shared_sigalgs); 496 if (c->ctypes) 497 OPENSSL_free(c->ctypes); 498 if (c->verify_store) 499 X509_STORE_free(c->verify_store); 500 if (c->chain_store) 501 X509_STORE_free(c->chain_store); 502 if (c->ciphers_raw) 503 OPENSSL_free(c->ciphers_raw); 504 #ifndef OPENSSL_NO_TLSEXT 505 custom_exts_free(&c->cli_ext); 506 custom_exts_free(&c->srv_ext); 507 if (c->alpn_proposed) 508 OPENSSL_free(c->alpn_proposed); 509 #endif 510 OPENSSL_free(c); 511 } 512 513 int ssl_cert_inst(CERT **o) 514 { 515 /* 516 * Create a CERT if there isn't already one (which cannot really happen, 517 * as it is initially created in SSL_CTX_new; but the earlier code 518 * usually allows for that one being non-existant, so we follow that 519 * behaviour, as it might turn out that there actually is a reason for it 520 * -- but I'm not sure that *all* of the existing code could cope with 521 * s->cert being NULL, otherwise we could do without the initialization 522 * in SSL_CTX_new). 523 */ 524 525 if (o == NULL) { 526 SSLerr(SSL_F_SSL_CERT_INST, ERR_R_PASSED_NULL_PARAMETER); 527 return (0); 528 } 529 if (*o == NULL) { 530 if ((*o = ssl_cert_new()) == NULL) { 531 SSLerr(SSL_F_SSL_CERT_INST, ERR_R_MALLOC_FAILURE); 532 return (0); 533 } 534 } 535 return (1); 536 } 537 538 int ssl_cert_set0_chain(CERT *c, STACK_OF(X509) *chain) 539 { 540 CERT_PKEY *cpk = c->key; 541 if (!cpk) 542 return 0; 543 if (cpk->chain) 544 sk_X509_pop_free(cpk->chain, X509_free); 545 cpk->chain = chain; 546 return 1; 547 } 548 549 int ssl_cert_set1_chain(CERT *c, STACK_OF(X509) *chain) 550 { 551 STACK_OF(X509) *dchain; 552 if (!chain) 553 return ssl_cert_set0_chain(c, NULL); 554 dchain = X509_chain_up_ref(chain); 555 if (!dchain) 556 return 0; 557 if (!ssl_cert_set0_chain(c, dchain)) { 558 sk_X509_pop_free(dchain, X509_free); 559 return 0; 560 } 561 return 1; 562 } 563 564 int ssl_cert_add0_chain_cert(CERT *c, X509 *x) 565 { 566 CERT_PKEY *cpk = c->key; 567 if (!cpk) 568 return 0; 569 if (!cpk->chain) 570 cpk->chain = sk_X509_new_null(); 571 if (!cpk->chain || !sk_X509_push(cpk->chain, x)) 572 return 0; 573 return 1; 574 } 575 576 int ssl_cert_add1_chain_cert(CERT *c, X509 *x) 577 { 578 if (!ssl_cert_add0_chain_cert(c, x)) 579 return 0; 580 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509); 581 return 1; 582 } 583 584 int ssl_cert_select_current(CERT *c, X509 *x) 585 { 586 int i; 587 if (x == NULL) 588 return 0; 589 for (i = 0; i < SSL_PKEY_NUM; i++) { 590 CERT_PKEY *cpk = c->pkeys + i; 591 if (cpk->x509 == x && cpk->privatekey) { 592 c->key = cpk; 593 return 1; 594 } 595 } 596 597 for (i = 0; i < SSL_PKEY_NUM; i++) { 598 CERT_PKEY *cpk = c->pkeys + i; 599 if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) { 600 c->key = cpk; 601 return 1; 602 } 603 } 604 return 0; 605 } 606 607 int ssl_cert_set_current(CERT *c, long op) 608 { 609 int i, idx; 610 if (!c) 611 return 0; 612 if (op == SSL_CERT_SET_FIRST) 613 idx = 0; 614 else if (op == SSL_CERT_SET_NEXT) { 615 idx = (int)(c->key - c->pkeys + 1); 616 if (idx >= SSL_PKEY_NUM) 617 return 0; 618 } else 619 return 0; 620 for (i = idx; i < SSL_PKEY_NUM; i++) { 621 CERT_PKEY *cpk = c->pkeys + i; 622 if (cpk->x509 && cpk->privatekey) { 623 c->key = cpk; 624 return 1; 625 } 626 } 627 return 0; 628 } 629 630 void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg) 631 { 632 c->cert_cb = cb; 633 c->cert_cb_arg = arg; 634 } 635 636 SESS_CERT *ssl_sess_cert_new(void) 637 { 638 SESS_CERT *ret; 639 640 ret = OPENSSL_malloc(sizeof *ret); 641 if (ret == NULL) { 642 SSLerr(SSL_F_SSL_SESS_CERT_NEW, ERR_R_MALLOC_FAILURE); 643 return NULL; 644 } 645 646 memset(ret, 0, sizeof *ret); 647 ret->peer_key = &(ret->peer_pkeys[SSL_PKEY_RSA_ENC]); 648 ret->references = 1; 649 650 return ret; 651 } 652 653 void ssl_sess_cert_free(SESS_CERT *sc) 654 { 655 int i; 656 657 if (sc == NULL) 658 return; 659 660 i = CRYPTO_add(&sc->references, -1, CRYPTO_LOCK_SSL_SESS_CERT); 661 #ifdef REF_PRINT 662 REF_PRINT("SESS_CERT", sc); 663 #endif 664 if (i > 0) 665 return; 666 #ifdef REF_CHECK 667 if (i < 0) { 668 fprintf(stderr, "ssl_sess_cert_free, bad reference count\n"); 669 abort(); /* ok */ 670 } 671 #endif 672 673 /* i == 0 */ 674 if (sc->cert_chain != NULL) 675 sk_X509_pop_free(sc->cert_chain, X509_free); 676 for (i = 0; i < SSL_PKEY_NUM; i++) { 677 if (sc->peer_pkeys[i].x509 != NULL) 678 X509_free(sc->peer_pkeys[i].x509); 679 #if 0 /* We don't have the peer's private key. 680 * These lines are just * here as a reminder 681 * that we're still using a 682 * not-quite-appropriate * data structure. */ 683 if (sc->peer_pkeys[i].privatekey != NULL) 684 EVP_PKEY_free(sc->peer_pkeys[i].privatekey); 685 #endif 686 } 687 688 #ifndef OPENSSL_NO_RSA 689 if (sc->peer_rsa_tmp != NULL) 690 RSA_free(sc->peer_rsa_tmp); 691 #endif 692 #ifndef OPENSSL_NO_DH 693 if (sc->peer_dh_tmp != NULL) 694 DH_free(sc->peer_dh_tmp); 695 #endif 696 #ifndef OPENSSL_NO_ECDH 697 if (sc->peer_ecdh_tmp != NULL) 698 EC_KEY_free(sc->peer_ecdh_tmp); 699 #endif 700 701 OPENSSL_free(sc); 702 } 703 704 int ssl_set_peer_cert_type(SESS_CERT *sc, int type) 705 { 706 sc->peer_cert_type = type; 707 return (1); 708 } 709 710 int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk) 711 { 712 X509 *x; 713 int i; 714 X509_STORE *verify_store; 715 X509_STORE_CTX ctx; 716 717 if (s->cert->verify_store) 718 verify_store = s->cert->verify_store; 719 else 720 verify_store = s->ctx->cert_store; 721 722 if ((sk == NULL) || (sk_X509_num(sk) == 0)) 723 return (0); 724 725 x = sk_X509_value(sk, 0); 726 if (!X509_STORE_CTX_init(&ctx, verify_store, x, sk)) { 727 SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, ERR_R_X509_LIB); 728 return (0); 729 } 730 /* Set suite B flags if needed */ 731 X509_STORE_CTX_set_flags(&ctx, tls1_suiteb(s)); 732 #if 0 733 if (SSL_get_verify_depth(s) >= 0) 734 X509_STORE_CTX_set_depth(&ctx, SSL_get_verify_depth(s)); 735 #endif 736 X509_STORE_CTX_set_ex_data(&ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s); 737 738 /* 739 * We need to inherit the verify parameters. These can be determined by 740 * the context: if its a server it will verify SSL client certificates or 741 * vice versa. 742 */ 743 744 X509_STORE_CTX_set_default(&ctx, s->server ? "ssl_client" : "ssl_server"); 745 /* 746 * Anything non-default in "param" should overwrite anything in the ctx. 747 */ 748 X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(&ctx), s->param); 749 750 if (s->verify_callback) 751 X509_STORE_CTX_set_verify_cb(&ctx, s->verify_callback); 752 753 if (s->ctx->app_verify_callback != NULL) 754 #if 1 /* new with OpenSSL 0.9.7 */ 755 i = s->ctx->app_verify_callback(&ctx, s->ctx->app_verify_arg); 756 #else 757 i = s->ctx->app_verify_callback(&ctx); /* should pass app_verify_arg */ 758 #endif 759 else { 760 #ifndef OPENSSL_NO_X509_VERIFY 761 i = X509_verify_cert(&ctx); 762 #else 763 i = 0; 764 ctx.error = X509_V_ERR_APPLICATION_VERIFICATION; 765 SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_NO_VERIFY_CALLBACK); 766 #endif 767 } 768 769 s->verify_result = ctx.error; 770 X509_STORE_CTX_cleanup(&ctx); 771 772 return (i); 773 } 774 775 static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list, 776 STACK_OF(X509_NAME) *name_list) 777 { 778 if (*ca_list != NULL) 779 sk_X509_NAME_pop_free(*ca_list, X509_NAME_free); 780 781 *ca_list = name_list; 782 } 783 784 STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk) 785 { 786 int i; 787 STACK_OF(X509_NAME) *ret; 788 X509_NAME *name; 789 790 ret = sk_X509_NAME_new_null(); 791 for (i = 0; i < sk_X509_NAME_num(sk); i++) { 792 name = X509_NAME_dup(sk_X509_NAME_value(sk, i)); 793 if ((name == NULL) || !sk_X509_NAME_push(ret, name)) { 794 sk_X509_NAME_pop_free(ret, X509_NAME_free); 795 return (NULL); 796 } 797 } 798 return (ret); 799 } 800 801 void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list) 802 { 803 set_client_CA_list(&(s->client_CA), name_list); 804 } 805 806 void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list) 807 { 808 set_client_CA_list(&(ctx->client_CA), name_list); 809 } 810 811 STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx) 812 { 813 return (ctx->client_CA); 814 } 815 816 STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s) 817 { 818 if (s->type == SSL_ST_CONNECT) { /* we are in the client */ 819 if (((s->version >> 8) == SSL3_VERSION_MAJOR) && (s->s3 != NULL)) 820 return (s->s3->tmp.ca_names); 821 else 822 return (NULL); 823 } else { 824 if (s->client_CA != NULL) 825 return (s->client_CA); 826 else 827 return (s->ctx->client_CA); 828 } 829 } 830 831 static int add_client_CA(STACK_OF(X509_NAME) **sk, X509 *x) 832 { 833 X509_NAME *name; 834 835 if (x == NULL) 836 return (0); 837 if ((*sk == NULL) && ((*sk = sk_X509_NAME_new_null()) == NULL)) 838 return (0); 839 840 if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL) 841 return (0); 842 843 if (!sk_X509_NAME_push(*sk, name)) { 844 X509_NAME_free(name); 845 return (0); 846 } 847 return (1); 848 } 849 850 int SSL_add_client_CA(SSL *ssl, X509 *x) 851 { 852 return (add_client_CA(&(ssl->client_CA), x)); 853 } 854 855 int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x) 856 { 857 return (add_client_CA(&(ctx->client_CA), x)); 858 } 859 860 static int xname_cmp(const X509_NAME *const *a, const X509_NAME *const *b) 861 { 862 return (X509_NAME_cmp(*a, *b)); 863 } 864 865 #ifndef OPENSSL_NO_STDIO 866 /** 867 * Load CA certs from a file into a ::STACK. Note that it is somewhat misnamed; 868 * it doesn't really have anything to do with clients (except that a common use 869 * for a stack of CAs is to send it to the client). Actually, it doesn't have 870 * much to do with CAs, either, since it will load any old cert. 871 * \param file the file containing one or more certs. 872 * \return a ::STACK containing the certs. 873 */ 874 STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file) 875 { 876 BIO *in; 877 X509 *x = NULL; 878 X509_NAME *xn = NULL; 879 STACK_OF(X509_NAME) *ret = NULL, *sk; 880 881 sk = sk_X509_NAME_new(xname_cmp); 882 883 in = BIO_new(BIO_s_file_internal()); 884 885 if ((sk == NULL) || (in == NULL)) { 886 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE); 887 goto err; 888 } 889 890 if (!BIO_read_filename(in, file)) 891 goto err; 892 893 for (;;) { 894 if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) 895 break; 896 if (ret == NULL) { 897 ret = sk_X509_NAME_new_null(); 898 if (ret == NULL) { 899 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE); 900 goto err; 901 } 902 } 903 if ((xn = X509_get_subject_name(x)) == NULL) 904 goto err; 905 /* check for duplicates */ 906 xn = X509_NAME_dup(xn); 907 if (xn == NULL) 908 goto err; 909 if (sk_X509_NAME_find(sk, xn) >= 0) 910 X509_NAME_free(xn); 911 else { 912 sk_X509_NAME_push(sk, xn); 913 sk_X509_NAME_push(ret, xn); 914 } 915 } 916 917 if (0) { 918 err: 919 if (ret != NULL) 920 sk_X509_NAME_pop_free(ret, X509_NAME_free); 921 ret = NULL; 922 } 923 if (sk != NULL) 924 sk_X509_NAME_free(sk); 925 if (in != NULL) 926 BIO_free(in); 927 if (x != NULL) 928 X509_free(x); 929 if (ret != NULL) 930 ERR_clear_error(); 931 return (ret); 932 } 933 #endif 934 935 /** 936 * Add a file of certs to a stack. 937 * \param stack the stack to add to. 938 * \param file the file to add from. All certs in this file that are not 939 * already in the stack will be added. 940 * \return 1 for success, 0 for failure. Note that in the case of failure some 941 * certs may have been added to \c stack. 942 */ 943 944 int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack, 945 const char *file) 946 { 947 BIO *in; 948 X509 *x = NULL; 949 X509_NAME *xn = NULL; 950 int ret = 1; 951 int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b); 952 953 oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_cmp); 954 955 in = BIO_new(BIO_s_file_internal()); 956 957 if (in == NULL) { 958 SSLerr(SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK, 959 ERR_R_MALLOC_FAILURE); 960 goto err; 961 } 962 963 if (!BIO_read_filename(in, file)) 964 goto err; 965 966 for (;;) { 967 if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) 968 break; 969 if ((xn = X509_get_subject_name(x)) == NULL) 970 goto err; 971 xn = X509_NAME_dup(xn); 972 if (xn == NULL) 973 goto err; 974 if (sk_X509_NAME_find(stack, xn) >= 0) 975 X509_NAME_free(xn); 976 else 977 sk_X509_NAME_push(stack, xn); 978 } 979 980 ERR_clear_error(); 981 982 if (0) { 983 err: 984 ret = 0; 985 } 986 if (in != NULL) 987 BIO_free(in); 988 if (x != NULL) 989 X509_free(x); 990 991 (void)sk_X509_NAME_set_cmp_func(stack, oldcmp); 992 993 return ret; 994 } 995 996 /** 997 * Add a directory of certs to a stack. 998 * \param stack the stack to append to. 999 * \param dir the directory to append from. All files in this directory will be 1000 * examined as potential certs. Any that are acceptable to 1001 * SSL_add_dir_cert_subjects_to_stack() that are not already in the stack will be 1002 * included. 1003 * \return 1 for success, 0 for failure. Note that in the case of failure some 1004 * certs may have been added to \c stack. 1005 */ 1006 1007 int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack, 1008 const char *dir) 1009 { 1010 OPENSSL_DIR_CTX *d = NULL; 1011 const char *filename; 1012 int ret = 0; 1013 1014 CRYPTO_w_lock(CRYPTO_LOCK_READDIR); 1015 1016 /* Note that a side effect is that the CAs will be sorted by name */ 1017 1018 while ((filename = OPENSSL_DIR_read(&d, dir))) { 1019 char buf[1024]; 1020 int r; 1021 1022 if (strlen(dir) + strlen(filename) + 2 > sizeof buf) { 1023 SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, 1024 SSL_R_PATH_TOO_LONG); 1025 goto err; 1026 } 1027 #ifdef OPENSSL_SYS_VMS 1028 r = BIO_snprintf(buf, sizeof buf, "%s%s", dir, filename); 1029 #else 1030 r = BIO_snprintf(buf, sizeof buf, "%s/%s", dir, filename); 1031 #endif 1032 if (r <= 0 || r >= (int)sizeof(buf)) 1033 goto err; 1034 if (!SSL_add_file_cert_subjects_to_stack(stack, buf)) 1035 goto err; 1036 } 1037 1038 if (errno) { 1039 SYSerr(SYS_F_OPENDIR, get_last_sys_error()); 1040 ERR_add_error_data(3, "OPENSSL_DIR_read(&ctx, '", dir, "')"); 1041 SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB); 1042 goto err; 1043 } 1044 1045 ret = 1; 1046 1047 err: 1048 if (d) 1049 OPENSSL_DIR_end(&d); 1050 CRYPTO_w_unlock(CRYPTO_LOCK_READDIR); 1051 return ret; 1052 } 1053 1054 /* Add a certificate to a BUF_MEM structure */ 1055 1056 static int ssl_add_cert_to_buf(BUF_MEM *buf, unsigned long *l, X509 *x) 1057 { 1058 int n; 1059 unsigned char *p; 1060 1061 n = i2d_X509(x, NULL); 1062 if (n < 0 || !BUF_MEM_grow_clean(buf, (int)(n + (*l) + 3))) { 1063 SSLerr(SSL_F_SSL_ADD_CERT_TO_BUF, ERR_R_BUF_LIB); 1064 return 0; 1065 } 1066 p = (unsigned char *)&(buf->data[*l]); 1067 l2n3(n, p); 1068 n = i2d_X509(x, &p); 1069 if (n < 0) { 1070 /* Shouldn't happen */ 1071 SSLerr(SSL_F_SSL_ADD_CERT_TO_BUF, ERR_R_BUF_LIB); 1072 return 0; 1073 } 1074 *l += n + 3; 1075 1076 return 1; 1077 } 1078 1079 /* Add certificate chain to internal SSL BUF_MEM strcuture */ 1080 int ssl_add_cert_chain(SSL *s, CERT_PKEY *cpk, unsigned long *l) 1081 { 1082 BUF_MEM *buf = s->init_buf; 1083 int no_chain; 1084 int i; 1085 1086 X509 *x; 1087 STACK_OF(X509) *extra_certs; 1088 X509_STORE *chain_store; 1089 1090 if (cpk) 1091 x = cpk->x509; 1092 else 1093 x = NULL; 1094 1095 if (s->cert->chain_store) 1096 chain_store = s->cert->chain_store; 1097 else 1098 chain_store = s->ctx->cert_store; 1099 1100 /* 1101 * If we have a certificate specific chain use it, else use parent ctx. 1102 */ 1103 if (cpk && cpk->chain) 1104 extra_certs = cpk->chain; 1105 else 1106 extra_certs = s->ctx->extra_certs; 1107 1108 if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs) 1109 no_chain = 1; 1110 else 1111 no_chain = 0; 1112 1113 /* TLSv1 sends a chain with nothing in it, instead of an alert */ 1114 if (!BUF_MEM_grow_clean(buf, 10)) { 1115 SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_BUF_LIB); 1116 return 0; 1117 } 1118 if (x != NULL) { 1119 if (no_chain) { 1120 if (!ssl_add_cert_to_buf(buf, l, x)) 1121 return 0; 1122 } else { 1123 X509_STORE_CTX xs_ctx; 1124 1125 if (!X509_STORE_CTX_init(&xs_ctx, chain_store, x, NULL)) { 1126 SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_X509_LIB); 1127 return (0); 1128 } 1129 X509_verify_cert(&xs_ctx); 1130 /* Don't leave errors in the queue */ 1131 ERR_clear_error(); 1132 for (i = 0; i < sk_X509_num(xs_ctx.chain); i++) { 1133 x = sk_X509_value(xs_ctx.chain, i); 1134 1135 if (!ssl_add_cert_to_buf(buf, l, x)) { 1136 X509_STORE_CTX_cleanup(&xs_ctx); 1137 return 0; 1138 } 1139 } 1140 X509_STORE_CTX_cleanup(&xs_ctx); 1141 } 1142 } 1143 for (i = 0; i < sk_X509_num(extra_certs); i++) { 1144 x = sk_X509_value(extra_certs, i); 1145 if (!ssl_add_cert_to_buf(buf, l, x)) 1146 return 0; 1147 } 1148 1149 return 1; 1150 } 1151 1152 /* Build a certificate chain for current certificate */ 1153 int ssl_build_cert_chain(CERT *c, X509_STORE *chain_store, int flags) 1154 { 1155 CERT_PKEY *cpk = c->key; 1156 X509_STORE_CTX xs_ctx; 1157 STACK_OF(X509) *chain = NULL, *untrusted = NULL; 1158 X509 *x; 1159 int i, rv = 0; 1160 unsigned long error; 1161 1162 if (!cpk->x509) { 1163 SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_NO_CERTIFICATE_SET); 1164 goto err; 1165 } 1166 /* Rearranging and check the chain: add everything to a store */ 1167 if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) { 1168 chain_store = X509_STORE_new(); 1169 if (!chain_store) 1170 goto err; 1171 for (i = 0; i < sk_X509_num(cpk->chain); i++) { 1172 x = sk_X509_value(cpk->chain, i); 1173 if (!X509_STORE_add_cert(chain_store, x)) { 1174 error = ERR_peek_last_error(); 1175 if (ERR_GET_LIB(error) != ERR_LIB_X509 || 1176 ERR_GET_REASON(error) != 1177 X509_R_CERT_ALREADY_IN_HASH_TABLE) 1178 goto err; 1179 ERR_clear_error(); 1180 } 1181 } 1182 /* Add EE cert too: it might be self signed */ 1183 if (!X509_STORE_add_cert(chain_store, cpk->x509)) { 1184 error = ERR_peek_last_error(); 1185 if (ERR_GET_LIB(error) != ERR_LIB_X509 || 1186 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE) 1187 goto err; 1188 ERR_clear_error(); 1189 } 1190 } else { 1191 if (c->chain_store) 1192 chain_store = c->chain_store; 1193 1194 if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED) 1195 untrusted = cpk->chain; 1196 } 1197 1198 if (!X509_STORE_CTX_init(&xs_ctx, chain_store, cpk->x509, untrusted)) { 1199 SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, ERR_R_X509_LIB); 1200 goto err; 1201 } 1202 /* Set suite B flags if needed */ 1203 X509_STORE_CTX_set_flags(&xs_ctx, 1204 c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS); 1205 1206 i = X509_verify_cert(&xs_ctx); 1207 if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) { 1208 if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR) 1209 ERR_clear_error(); 1210 i = 1; 1211 rv = 2; 1212 } 1213 if (i > 0) 1214 chain = X509_STORE_CTX_get1_chain(&xs_ctx); 1215 if (i <= 0) { 1216 SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_CERTIFICATE_VERIFY_FAILED); 1217 i = X509_STORE_CTX_get_error(&xs_ctx); 1218 ERR_add_error_data(2, "Verify error:", 1219 X509_verify_cert_error_string(i)); 1220 1221 X509_STORE_CTX_cleanup(&xs_ctx); 1222 goto err; 1223 } 1224 X509_STORE_CTX_cleanup(&xs_ctx); 1225 if (cpk->chain) 1226 sk_X509_pop_free(cpk->chain, X509_free); 1227 /* Remove EE certificate from chain */ 1228 x = sk_X509_shift(chain); 1229 X509_free(x); 1230 if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) { 1231 if (sk_X509_num(chain) > 0) { 1232 /* See if last cert is self signed */ 1233 x = sk_X509_value(chain, sk_X509_num(chain) - 1); 1234 X509_check_purpose(x, -1, 0); 1235 if (x->ex_flags & EXFLAG_SS) { 1236 x = sk_X509_pop(chain); 1237 X509_free(x); 1238 } 1239 } 1240 } 1241 cpk->chain = chain; 1242 if (rv == 0) 1243 rv = 1; 1244 err: 1245 if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) 1246 X509_STORE_free(chain_store); 1247 1248 return rv; 1249 } 1250 1251 int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref) 1252 { 1253 X509_STORE **pstore; 1254 if (chain) 1255 pstore = &c->chain_store; 1256 else 1257 pstore = &c->verify_store; 1258 if (*pstore) 1259 X509_STORE_free(*pstore); 1260 *pstore = store; 1261 if (ref && store) 1262 CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE); 1263 return 1; 1264 } 1265