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 goto err; 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 err: 396 #ifndef OPENSSL_NO_RSA 397 if (ret->rsa_tmp != NULL) 398 RSA_free(ret->rsa_tmp); 399 #endif 400 #ifndef OPENSSL_NO_DH 401 if (ret->dh_tmp != NULL) 402 DH_free(ret->dh_tmp); 403 #endif 404 #ifndef OPENSSL_NO_ECDH 405 if (ret->ecdh_tmp != NULL) 406 EC_KEY_free(ret->ecdh_tmp); 407 #endif 408 409 #ifndef OPENSSL_NO_TLSEXT 410 custom_exts_free(&ret->cli_ext); 411 custom_exts_free(&ret->srv_ext); 412 #endif 413 414 ssl_cert_clear_certs(ret); 415 OPENSSL_free(ret); 416 417 return NULL; 418 } 419 420 /* Free up and clear all certificates and chains */ 421 422 void ssl_cert_clear_certs(CERT *c) 423 { 424 int i; 425 if (c == NULL) 426 return; 427 for (i = 0; i < SSL_PKEY_NUM; i++) { 428 CERT_PKEY *cpk = c->pkeys + i; 429 if (cpk->x509) { 430 X509_free(cpk->x509); 431 cpk->x509 = NULL; 432 } 433 if (cpk->privatekey) { 434 EVP_PKEY_free(cpk->privatekey); 435 cpk->privatekey = NULL; 436 } 437 if (cpk->chain) { 438 sk_X509_pop_free(cpk->chain, X509_free); 439 cpk->chain = NULL; 440 } 441 #ifndef OPENSSL_NO_TLSEXT 442 if (cpk->serverinfo) { 443 OPENSSL_free(cpk->serverinfo); 444 cpk->serverinfo = NULL; 445 cpk->serverinfo_length = 0; 446 } 447 #endif 448 /* Clear all flags apart from explicit sign */ 449 cpk->valid_flags &= CERT_PKEY_EXPLICIT_SIGN; 450 } 451 } 452 453 void ssl_cert_free(CERT *c) 454 { 455 int i; 456 457 if (c == NULL) 458 return; 459 460 i = CRYPTO_add(&c->references, -1, CRYPTO_LOCK_SSL_CERT); 461 #ifdef REF_PRINT 462 REF_PRINT("CERT", c); 463 #endif 464 if (i > 0) 465 return; 466 #ifdef REF_CHECK 467 if (i < 0) { 468 fprintf(stderr, "ssl_cert_free, bad reference count\n"); 469 abort(); /* ok */ 470 } 471 #endif 472 473 #ifndef OPENSSL_NO_RSA 474 if (c->rsa_tmp) 475 RSA_free(c->rsa_tmp); 476 #endif 477 #ifndef OPENSSL_NO_DH 478 if (c->dh_tmp) 479 DH_free(c->dh_tmp); 480 #endif 481 #ifndef OPENSSL_NO_ECDH 482 if (c->ecdh_tmp) 483 EC_KEY_free(c->ecdh_tmp); 484 #endif 485 486 ssl_cert_clear_certs(c); 487 if (c->peer_sigalgs) 488 OPENSSL_free(c->peer_sigalgs); 489 if (c->conf_sigalgs) 490 OPENSSL_free(c->conf_sigalgs); 491 if (c->client_sigalgs) 492 OPENSSL_free(c->client_sigalgs); 493 if (c->shared_sigalgs) 494 OPENSSL_free(c->shared_sigalgs); 495 if (c->ctypes) 496 OPENSSL_free(c->ctypes); 497 if (c->verify_store) 498 X509_STORE_free(c->verify_store); 499 if (c->chain_store) 500 X509_STORE_free(c->chain_store); 501 if (c->ciphers_raw) 502 OPENSSL_free(c->ciphers_raw); 503 #ifndef OPENSSL_NO_TLSEXT 504 custom_exts_free(&c->cli_ext); 505 custom_exts_free(&c->srv_ext); 506 if (c->alpn_proposed) 507 OPENSSL_free(c->alpn_proposed); 508 #endif 509 OPENSSL_free(c); 510 } 511 512 int ssl_cert_inst(CERT **o) 513 { 514 /* 515 * Create a CERT if there isn't already one (which cannot really happen, 516 * as it is initially created in SSL_CTX_new; but the earlier code 517 * usually allows for that one being non-existant, so we follow that 518 * behaviour, as it might turn out that there actually is a reason for it 519 * -- but I'm not sure that *all* of the existing code could cope with 520 * s->cert being NULL, otherwise we could do without the initialization 521 * in SSL_CTX_new). 522 */ 523 524 if (o == NULL) { 525 SSLerr(SSL_F_SSL_CERT_INST, ERR_R_PASSED_NULL_PARAMETER); 526 return (0); 527 } 528 if (*o == NULL) { 529 if ((*o = ssl_cert_new()) == NULL) { 530 SSLerr(SSL_F_SSL_CERT_INST, ERR_R_MALLOC_FAILURE); 531 return (0); 532 } 533 } 534 return (1); 535 } 536 537 int ssl_cert_set0_chain(CERT *c, STACK_OF(X509) *chain) 538 { 539 CERT_PKEY *cpk = c->key; 540 if (!cpk) 541 return 0; 542 if (cpk->chain) 543 sk_X509_pop_free(cpk->chain, X509_free); 544 cpk->chain = chain; 545 return 1; 546 } 547 548 int ssl_cert_set1_chain(CERT *c, STACK_OF(X509) *chain) 549 { 550 STACK_OF(X509) *dchain; 551 if (!chain) 552 return ssl_cert_set0_chain(c, NULL); 553 dchain = X509_chain_up_ref(chain); 554 if (!dchain) 555 return 0; 556 if (!ssl_cert_set0_chain(c, dchain)) { 557 sk_X509_pop_free(dchain, X509_free); 558 return 0; 559 } 560 return 1; 561 } 562 563 int ssl_cert_add0_chain_cert(CERT *c, X509 *x) 564 { 565 CERT_PKEY *cpk = c->key; 566 if (!cpk) 567 return 0; 568 if (!cpk->chain) 569 cpk->chain = sk_X509_new_null(); 570 if (!cpk->chain || !sk_X509_push(cpk->chain, x)) 571 return 0; 572 return 1; 573 } 574 575 int ssl_cert_add1_chain_cert(CERT *c, X509 *x) 576 { 577 if (!ssl_cert_add0_chain_cert(c, x)) 578 return 0; 579 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509); 580 return 1; 581 } 582 583 int ssl_cert_select_current(CERT *c, X509 *x) 584 { 585 int i; 586 if (x == NULL) 587 return 0; 588 for (i = 0; i < SSL_PKEY_NUM; i++) { 589 CERT_PKEY *cpk = c->pkeys + i; 590 if (cpk->x509 == x && cpk->privatekey) { 591 c->key = cpk; 592 return 1; 593 } 594 } 595 596 for (i = 0; i < SSL_PKEY_NUM; i++) { 597 CERT_PKEY *cpk = c->pkeys + i; 598 if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) { 599 c->key = cpk; 600 return 1; 601 } 602 } 603 return 0; 604 } 605 606 int ssl_cert_set_current(CERT *c, long op) 607 { 608 int i, idx; 609 if (!c) 610 return 0; 611 if (op == SSL_CERT_SET_FIRST) 612 idx = 0; 613 else if (op == SSL_CERT_SET_NEXT) { 614 idx = (int)(c->key - c->pkeys + 1); 615 if (idx >= SSL_PKEY_NUM) 616 return 0; 617 } else 618 return 0; 619 for (i = idx; i < SSL_PKEY_NUM; i++) { 620 CERT_PKEY *cpk = c->pkeys + i; 621 if (cpk->x509 && cpk->privatekey) { 622 c->key = cpk; 623 return 1; 624 } 625 } 626 return 0; 627 } 628 629 void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg) 630 { 631 c->cert_cb = cb; 632 c->cert_cb_arg = arg; 633 } 634 635 SESS_CERT *ssl_sess_cert_new(void) 636 { 637 SESS_CERT *ret; 638 639 ret = OPENSSL_malloc(sizeof(*ret)); 640 if (ret == NULL) { 641 SSLerr(SSL_F_SSL_SESS_CERT_NEW, ERR_R_MALLOC_FAILURE); 642 return NULL; 643 } 644 645 memset(ret, 0, sizeof(*ret)); 646 ret->peer_key = &(ret->peer_pkeys[SSL_PKEY_RSA_ENC]); 647 ret->references = 1; 648 649 return ret; 650 } 651 652 void ssl_sess_cert_free(SESS_CERT *sc) 653 { 654 int i; 655 656 if (sc == NULL) 657 return; 658 659 i = CRYPTO_add(&sc->references, -1, CRYPTO_LOCK_SSL_SESS_CERT); 660 #ifdef REF_PRINT 661 REF_PRINT("SESS_CERT", sc); 662 #endif 663 if (i > 0) 664 return; 665 #ifdef REF_CHECK 666 if (i < 0) { 667 fprintf(stderr, "ssl_sess_cert_free, bad reference count\n"); 668 abort(); /* ok */ 669 } 670 #endif 671 672 /* i == 0 */ 673 if (sc->cert_chain != NULL) 674 sk_X509_pop_free(sc->cert_chain, X509_free); 675 for (i = 0; i < SSL_PKEY_NUM; i++) { 676 if (sc->peer_pkeys[i].x509 != NULL) 677 X509_free(sc->peer_pkeys[i].x509); 678 #if 0 /* We don't have the peer's private key. 679 * These lines are just * here as a reminder 680 * that we're still using a 681 * not-quite-appropriate * data structure. */ 682 if (sc->peer_pkeys[i].privatekey != NULL) 683 EVP_PKEY_free(sc->peer_pkeys[i].privatekey); 684 #endif 685 } 686 687 #ifndef OPENSSL_NO_RSA 688 if (sc->peer_rsa_tmp != NULL) 689 RSA_free(sc->peer_rsa_tmp); 690 #endif 691 #ifndef OPENSSL_NO_DH 692 if (sc->peer_dh_tmp != NULL) 693 DH_free(sc->peer_dh_tmp); 694 #endif 695 #ifndef OPENSSL_NO_ECDH 696 if (sc->peer_ecdh_tmp != NULL) 697 EC_KEY_free(sc->peer_ecdh_tmp); 698 #endif 699 700 OPENSSL_free(sc); 701 } 702 703 int ssl_set_peer_cert_type(SESS_CERT *sc, int type) 704 { 705 sc->peer_cert_type = type; 706 return (1); 707 } 708 709 int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk) 710 { 711 X509 *x; 712 int i; 713 X509_STORE *verify_store; 714 X509_STORE_CTX ctx; 715 716 if (s->cert->verify_store) 717 verify_store = s->cert->verify_store; 718 else 719 verify_store = s->ctx->cert_store; 720 721 if ((sk == NULL) || (sk_X509_num(sk) == 0)) 722 return (0); 723 724 x = sk_X509_value(sk, 0); 725 if (!X509_STORE_CTX_init(&ctx, verify_store, x, sk)) { 726 SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, ERR_R_X509_LIB); 727 return (0); 728 } 729 /* Set suite B flags if needed */ 730 X509_STORE_CTX_set_flags(&ctx, tls1_suiteb(s)); 731 #if 0 732 if (SSL_get_verify_depth(s) >= 0) 733 X509_STORE_CTX_set_depth(&ctx, SSL_get_verify_depth(s)); 734 #endif 735 X509_STORE_CTX_set_ex_data(&ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s); 736 737 /* 738 * We need to inherit the verify parameters. These can be determined by 739 * the context: if its a server it will verify SSL client certificates or 740 * vice versa. 741 */ 742 743 X509_STORE_CTX_set_default(&ctx, s->server ? "ssl_client" : "ssl_server"); 744 /* 745 * Anything non-default in "param" should overwrite anything in the ctx. 746 */ 747 X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(&ctx), s->param); 748 749 if (s->verify_callback) 750 X509_STORE_CTX_set_verify_cb(&ctx, s->verify_callback); 751 752 if (s->ctx->app_verify_callback != NULL) 753 #if 1 /* new with OpenSSL 0.9.7 */ 754 i = s->ctx->app_verify_callback(&ctx, s->ctx->app_verify_arg); 755 #else 756 i = s->ctx->app_verify_callback(&ctx); /* should pass app_verify_arg */ 757 #endif 758 else { 759 #ifndef OPENSSL_NO_X509_VERIFY 760 i = X509_verify_cert(&ctx); 761 #else 762 i = 0; 763 ctx.error = X509_V_ERR_APPLICATION_VERIFICATION; 764 SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_NO_VERIFY_CALLBACK); 765 #endif 766 } 767 768 s->verify_result = ctx.error; 769 X509_STORE_CTX_cleanup(&ctx); 770 771 return (i); 772 } 773 774 static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list, 775 STACK_OF(X509_NAME) *name_list) 776 { 777 if (*ca_list != NULL) 778 sk_X509_NAME_pop_free(*ca_list, X509_NAME_free); 779 780 *ca_list = name_list; 781 } 782 783 STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk) 784 { 785 int i; 786 STACK_OF(X509_NAME) *ret; 787 X509_NAME *name; 788 789 ret = sk_X509_NAME_new_null(); 790 for (i = 0; i < sk_X509_NAME_num(sk); i++) { 791 name = X509_NAME_dup(sk_X509_NAME_value(sk, i)); 792 if ((name == NULL) || !sk_X509_NAME_push(ret, name)) { 793 sk_X509_NAME_pop_free(ret, X509_NAME_free); 794 return (NULL); 795 } 796 } 797 return (ret); 798 } 799 800 void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list) 801 { 802 set_client_CA_list(&(s->client_CA), name_list); 803 } 804 805 void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list) 806 { 807 set_client_CA_list(&(ctx->client_CA), name_list); 808 } 809 810 STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx) 811 { 812 return (ctx->client_CA); 813 } 814 815 STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s) 816 { 817 if (s->type == SSL_ST_CONNECT) { /* we are in the client */ 818 if (((s->version >> 8) == SSL3_VERSION_MAJOR) && (s->s3 != NULL)) 819 return (s->s3->tmp.ca_names); 820 else 821 return (NULL); 822 } else { 823 if (s->client_CA != NULL) 824 return (s->client_CA); 825 else 826 return (s->ctx->client_CA); 827 } 828 } 829 830 static int add_client_CA(STACK_OF(X509_NAME) **sk, X509 *x) 831 { 832 X509_NAME *name; 833 834 if (x == NULL) 835 return (0); 836 if ((*sk == NULL) && ((*sk = sk_X509_NAME_new_null()) == NULL)) 837 return (0); 838 839 if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL) 840 return (0); 841 842 if (!sk_X509_NAME_push(*sk, name)) { 843 X509_NAME_free(name); 844 return (0); 845 } 846 return (1); 847 } 848 849 int SSL_add_client_CA(SSL *ssl, X509 *x) 850 { 851 return (add_client_CA(&(ssl->client_CA), x)); 852 } 853 854 int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x) 855 { 856 return (add_client_CA(&(ctx->client_CA), x)); 857 } 858 859 static int xname_cmp(const X509_NAME *const *a, const X509_NAME *const *b) 860 { 861 return (X509_NAME_cmp(*a, *b)); 862 } 863 864 #ifndef OPENSSL_NO_STDIO 865 /** 866 * Load CA certs from a file into a ::STACK. Note that it is somewhat misnamed; 867 * it doesn't really have anything to do with clients (except that a common use 868 * for a stack of CAs is to send it to the client). Actually, it doesn't have 869 * much to do with CAs, either, since it will load any old cert. 870 * \param file the file containing one or more certs. 871 * \return a ::STACK containing the certs. 872 */ 873 STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file) 874 { 875 BIO *in; 876 X509 *x = NULL; 877 X509_NAME *xn = NULL; 878 STACK_OF(X509_NAME) *ret = NULL, *sk; 879 880 sk = sk_X509_NAME_new(xname_cmp); 881 882 in = BIO_new(BIO_s_file_internal()); 883 884 if ((sk == NULL) || (in == NULL)) { 885 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE); 886 goto err; 887 } 888 889 if (!BIO_read_filename(in, file)) 890 goto err; 891 892 for (;;) { 893 if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) 894 break; 895 if (ret == NULL) { 896 ret = sk_X509_NAME_new_null(); 897 if (ret == NULL) { 898 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE); 899 goto err; 900 } 901 } 902 if ((xn = X509_get_subject_name(x)) == NULL) 903 goto err; 904 /* check for duplicates */ 905 xn = X509_NAME_dup(xn); 906 if (xn == NULL) 907 goto err; 908 if (sk_X509_NAME_find(sk, xn) >= 0) 909 X509_NAME_free(xn); 910 else { 911 sk_X509_NAME_push(sk, xn); 912 sk_X509_NAME_push(ret, xn); 913 } 914 } 915 916 if (0) { 917 err: 918 if (ret != NULL) 919 sk_X509_NAME_pop_free(ret, X509_NAME_free); 920 ret = NULL; 921 } 922 if (sk != NULL) 923 sk_X509_NAME_free(sk); 924 if (in != NULL) 925 BIO_free(in); 926 if (x != NULL) 927 X509_free(x); 928 if (ret != NULL) 929 ERR_clear_error(); 930 return (ret); 931 } 932 #endif 933 934 /** 935 * Add a file of certs to a stack. 936 * \param stack the stack to add to. 937 * \param file the file to add from. All certs in this file that are not 938 * already in the stack will be added. 939 * \return 1 for success, 0 for failure. Note that in the case of failure some 940 * certs may have been added to \c stack. 941 */ 942 943 int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack, 944 const char *file) 945 { 946 BIO *in; 947 X509 *x = NULL; 948 X509_NAME *xn = NULL; 949 int ret = 1; 950 int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b); 951 952 oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_cmp); 953 954 in = BIO_new(BIO_s_file_internal()); 955 956 if (in == NULL) { 957 SSLerr(SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK, 958 ERR_R_MALLOC_FAILURE); 959 goto err; 960 } 961 962 if (!BIO_read_filename(in, file)) 963 goto err; 964 965 for (;;) { 966 if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) 967 break; 968 if ((xn = X509_get_subject_name(x)) == NULL) 969 goto err; 970 xn = X509_NAME_dup(xn); 971 if (xn == NULL) 972 goto err; 973 if (sk_X509_NAME_find(stack, xn) >= 0) 974 X509_NAME_free(xn); 975 else 976 sk_X509_NAME_push(stack, xn); 977 } 978 979 ERR_clear_error(); 980 981 if (0) { 982 err: 983 ret = 0; 984 } 985 if (in != NULL) 986 BIO_free(in); 987 if (x != NULL) 988 X509_free(x); 989 990 (void)sk_X509_NAME_set_cmp_func(stack, oldcmp); 991 992 return ret; 993 } 994 995 /** 996 * Add a directory of certs to a stack. 997 * \param stack the stack to append to. 998 * \param dir the directory to append from. All files in this directory will be 999 * examined as potential certs. Any that are acceptable to 1000 * SSL_add_dir_cert_subjects_to_stack() that are not already in the stack will be 1001 * included. 1002 * \return 1 for success, 0 for failure. Note that in the case of failure some 1003 * certs may have been added to \c stack. 1004 */ 1005 1006 int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack, 1007 const char *dir) 1008 { 1009 OPENSSL_DIR_CTX *d = NULL; 1010 const char *filename; 1011 int ret = 0; 1012 1013 CRYPTO_w_lock(CRYPTO_LOCK_READDIR); 1014 1015 /* Note that a side effect is that the CAs will be sorted by name */ 1016 1017 while ((filename = OPENSSL_DIR_read(&d, dir))) { 1018 char buf[1024]; 1019 int r; 1020 1021 if (strlen(dir) + strlen(filename) + 2 > sizeof(buf)) { 1022 SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, 1023 SSL_R_PATH_TOO_LONG); 1024 goto err; 1025 } 1026 #ifdef OPENSSL_SYS_VMS 1027 r = BIO_snprintf(buf, sizeof(buf), "%s%s", dir, filename); 1028 #else 1029 r = BIO_snprintf(buf, sizeof(buf), "%s/%s", dir, filename); 1030 #endif 1031 if (r <= 0 || r >= (int)sizeof(buf)) 1032 goto err; 1033 if (!SSL_add_file_cert_subjects_to_stack(stack, buf)) 1034 goto err; 1035 } 1036 1037 if (errno) { 1038 SYSerr(SYS_F_OPENDIR, get_last_sys_error()); 1039 ERR_add_error_data(3, "OPENSSL_DIR_read(&ctx, '", dir, "')"); 1040 SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB); 1041 goto err; 1042 } 1043 1044 ret = 1; 1045 1046 err: 1047 if (d) 1048 OPENSSL_DIR_end(&d); 1049 CRYPTO_w_unlock(CRYPTO_LOCK_READDIR); 1050 return ret; 1051 } 1052 1053 /* Add a certificate to a BUF_MEM structure */ 1054 1055 static int ssl_add_cert_to_buf(BUF_MEM *buf, unsigned long *l, X509 *x) 1056 { 1057 int n; 1058 unsigned char *p; 1059 1060 n = i2d_X509(x, NULL); 1061 if (n < 0 || !BUF_MEM_grow_clean(buf, (int)(n + (*l) + 3))) { 1062 SSLerr(SSL_F_SSL_ADD_CERT_TO_BUF, ERR_R_BUF_LIB); 1063 return 0; 1064 } 1065 p = (unsigned char *)&(buf->data[*l]); 1066 l2n3(n, p); 1067 n = i2d_X509(x, &p); 1068 if (n < 0) { 1069 /* Shouldn't happen */ 1070 SSLerr(SSL_F_SSL_ADD_CERT_TO_BUF, ERR_R_BUF_LIB); 1071 return 0; 1072 } 1073 *l += n + 3; 1074 1075 return 1; 1076 } 1077 1078 /* Add certificate chain to internal SSL BUF_MEM strcuture */ 1079 int ssl_add_cert_chain(SSL *s, CERT_PKEY *cpk, unsigned long *l) 1080 { 1081 BUF_MEM *buf = s->init_buf; 1082 int no_chain; 1083 int i; 1084 1085 X509 *x; 1086 STACK_OF(X509) *extra_certs; 1087 X509_STORE *chain_store; 1088 1089 if (cpk) 1090 x = cpk->x509; 1091 else 1092 x = NULL; 1093 1094 if (s->cert->chain_store) 1095 chain_store = s->cert->chain_store; 1096 else 1097 chain_store = s->ctx->cert_store; 1098 1099 /* 1100 * If we have a certificate specific chain use it, else use parent ctx. 1101 */ 1102 if (cpk && cpk->chain) 1103 extra_certs = cpk->chain; 1104 else 1105 extra_certs = s->ctx->extra_certs; 1106 1107 if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs) 1108 no_chain = 1; 1109 else 1110 no_chain = 0; 1111 1112 /* TLSv1 sends a chain with nothing in it, instead of an alert */ 1113 if (!BUF_MEM_grow_clean(buf, 10)) { 1114 SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_BUF_LIB); 1115 return 0; 1116 } 1117 if (x != NULL) { 1118 if (no_chain) { 1119 if (!ssl_add_cert_to_buf(buf, l, x)) 1120 return 0; 1121 } else { 1122 X509_STORE_CTX xs_ctx; 1123 1124 if (!X509_STORE_CTX_init(&xs_ctx, chain_store, x, NULL)) { 1125 SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_X509_LIB); 1126 return (0); 1127 } 1128 X509_verify_cert(&xs_ctx); 1129 /* Don't leave errors in the queue */ 1130 ERR_clear_error(); 1131 for (i = 0; i < sk_X509_num(xs_ctx.chain); i++) { 1132 x = sk_X509_value(xs_ctx.chain, i); 1133 1134 if (!ssl_add_cert_to_buf(buf, l, x)) { 1135 X509_STORE_CTX_cleanup(&xs_ctx); 1136 return 0; 1137 } 1138 } 1139 X509_STORE_CTX_cleanup(&xs_ctx); 1140 } 1141 } 1142 for (i = 0; i < sk_X509_num(extra_certs); i++) { 1143 x = sk_X509_value(extra_certs, i); 1144 if (!ssl_add_cert_to_buf(buf, l, x)) 1145 return 0; 1146 } 1147 1148 return 1; 1149 } 1150 1151 /* Build a certificate chain for current certificate */ 1152 int ssl_build_cert_chain(CERT *c, X509_STORE *chain_store, int flags) 1153 { 1154 CERT_PKEY *cpk = c->key; 1155 X509_STORE_CTX xs_ctx; 1156 STACK_OF(X509) *chain = NULL, *untrusted = NULL; 1157 X509 *x; 1158 int i, rv = 0; 1159 unsigned long error; 1160 1161 if (!cpk->x509) { 1162 SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_NO_CERTIFICATE_SET); 1163 goto err; 1164 } 1165 /* Rearranging and check the chain: add everything to a store */ 1166 if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) { 1167 chain_store = X509_STORE_new(); 1168 if (!chain_store) 1169 goto err; 1170 for (i = 0; i < sk_X509_num(cpk->chain); i++) { 1171 x = sk_X509_value(cpk->chain, i); 1172 if (!X509_STORE_add_cert(chain_store, x)) { 1173 error = ERR_peek_last_error(); 1174 if (ERR_GET_LIB(error) != ERR_LIB_X509 || 1175 ERR_GET_REASON(error) != 1176 X509_R_CERT_ALREADY_IN_HASH_TABLE) 1177 goto err; 1178 ERR_clear_error(); 1179 } 1180 } 1181 /* Add EE cert too: it might be self signed */ 1182 if (!X509_STORE_add_cert(chain_store, cpk->x509)) { 1183 error = ERR_peek_last_error(); 1184 if (ERR_GET_LIB(error) != ERR_LIB_X509 || 1185 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE) 1186 goto err; 1187 ERR_clear_error(); 1188 } 1189 } else { 1190 if (c->chain_store) 1191 chain_store = c->chain_store; 1192 1193 if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED) 1194 untrusted = cpk->chain; 1195 } 1196 1197 if (!X509_STORE_CTX_init(&xs_ctx, chain_store, cpk->x509, untrusted)) { 1198 SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, ERR_R_X509_LIB); 1199 goto err; 1200 } 1201 /* Set suite B flags if needed */ 1202 X509_STORE_CTX_set_flags(&xs_ctx, 1203 c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS); 1204 1205 i = X509_verify_cert(&xs_ctx); 1206 if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) { 1207 if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR) 1208 ERR_clear_error(); 1209 i = 1; 1210 rv = 2; 1211 } 1212 if (i > 0) 1213 chain = X509_STORE_CTX_get1_chain(&xs_ctx); 1214 if (i <= 0) { 1215 SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_CERTIFICATE_VERIFY_FAILED); 1216 i = X509_STORE_CTX_get_error(&xs_ctx); 1217 ERR_add_error_data(2, "Verify error:", 1218 X509_verify_cert_error_string(i)); 1219 1220 X509_STORE_CTX_cleanup(&xs_ctx); 1221 goto err; 1222 } 1223 X509_STORE_CTX_cleanup(&xs_ctx); 1224 if (cpk->chain) 1225 sk_X509_pop_free(cpk->chain, X509_free); 1226 /* Remove EE certificate from chain */ 1227 x = sk_X509_shift(chain); 1228 X509_free(x); 1229 if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) { 1230 if (sk_X509_num(chain) > 0) { 1231 /* See if last cert is self signed */ 1232 x = sk_X509_value(chain, sk_X509_num(chain) - 1); 1233 X509_check_purpose(x, -1, 0); 1234 if (x->ex_flags & EXFLAG_SS) { 1235 x = sk_X509_pop(chain); 1236 X509_free(x); 1237 } 1238 } 1239 } 1240 cpk->chain = chain; 1241 if (rv == 0) 1242 rv = 1; 1243 err: 1244 if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) 1245 X509_STORE_free(chain_store); 1246 1247 return rv; 1248 } 1249 1250 int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref) 1251 { 1252 X509_STORE **pstore; 1253 if (chain) 1254 pstore = &c->chain_store; 1255 else 1256 pstore = &c->verify_store; 1257 if (*pstore) 1258 X509_STORE_free(*pstore); 1259 *pstore = store; 1260 if (ref && store) 1261 CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE); 1262 return 1; 1263 } 1264