x509_vfy.c revision 284295
1/* crypto/x509/x509_vfy.c */ 2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 3 * All rights reserved. 4 * 5 * This package is an SSL implementation written 6 * by Eric Young (eay@cryptsoft.com). 7 * The implementation was written so as to conform with Netscapes SSL. 8 * 9 * This library is free for commercial and non-commercial use as long as 10 * the following conditions are aheared to. The following conditions 11 * apply to all code found in this distribution, be it the RC4, RSA, 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 13 * included with this distribution is covered by the same copyright terms 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15 * 16 * Copyright remains Eric Young's, and as such any Copyright notices in 17 * the code are not to be removed. 18 * If this package is used in a product, Eric Young should be given attribution 19 * as the author of the parts of the library used. 20 * This can be in the form of a textual message at program startup or 21 * in documentation (online or textual) provided with the package. 22 * 23 * Redistribution and use in source and binary forms, with or without 24 * modification, are permitted provided that the following conditions 25 * are met: 26 * 1. Redistributions of source code must retain the copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 2. Redistributions in binary form must reproduce the above copyright 29 * notice, this list of conditions and the following disclaimer in the 30 * documentation and/or other materials provided with the distribution. 31 * 3. All advertising materials mentioning features or use of this software 32 * must display the following acknowledgement: 33 * "This product includes cryptographic software written by 34 * Eric Young (eay@cryptsoft.com)" 35 * The word 'cryptographic' can be left out if the rouines from the library 36 * being used are not cryptographic related :-). 37 * 4. If you include any Windows specific code (or a derivative thereof) from 38 * the apps directory (application code) you must include an acknowledgement: 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40 * 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * The licence and distribution terms for any publically available version or 54 * derivative of this code cannot be changed. i.e. this code cannot simply be 55 * copied and put under another distribution licence 56 * [including the GNU Public Licence.] 57 */ 58 59#include <stdio.h> 60#include <time.h> 61#include <errno.h> 62 63#include "cryptlib.h" 64#include <openssl/crypto.h> 65#include <openssl/lhash.h> 66#include <openssl/buffer.h> 67#include <openssl/evp.h> 68#include <openssl/asn1.h> 69#include <openssl/x509.h> 70#include <openssl/x509v3.h> 71#include <openssl/objects.h> 72 73static int null_callback(int ok,X509_STORE_CTX *e); 74static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer); 75static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x); 76static int check_chain_extensions(X509_STORE_CTX *ctx); 77static int check_trust(X509_STORE_CTX *ctx); 78static int check_revocation(X509_STORE_CTX *ctx); 79static int check_cert(X509_STORE_CTX *ctx); 80static int check_policy(X509_STORE_CTX *ctx); 81static int internal_verify(X509_STORE_CTX *ctx); 82const char X509_version[]="X.509" OPENSSL_VERSION_PTEXT; 83 84 85static int null_callback(int ok, X509_STORE_CTX *e) 86 { 87 return ok; 88 } 89 90#if 0 91static int x509_subject_cmp(X509 **a, X509 **b) 92 { 93 return X509_subject_name_cmp(*a,*b); 94 } 95#endif 96 97int X509_verify_cert(X509_STORE_CTX *ctx) 98 { 99 X509 *x,*xtmp,*chain_ss=NULL; 100 int bad_chain = 0; 101 X509_VERIFY_PARAM *param = ctx->param; 102 int depth,i,ok=0; 103 int num; 104 int (*cb)(int xok,X509_STORE_CTX *xctx); 105 STACK_OF(X509) *sktmp=NULL; 106 if (ctx->cert == NULL) 107 { 108 X509err(X509_F_X509_VERIFY_CERT,X509_R_NO_CERT_SET_FOR_US_TO_VERIFY); 109 return -1; 110 } 111 112 cb=ctx->verify_cb; 113 114 /* first we make sure the chain we are going to build is 115 * present and that the first entry is in place */ 116 if (ctx->chain == NULL) 117 { 118 if ( ((ctx->chain=sk_X509_new_null()) == NULL) || 119 (!sk_X509_push(ctx->chain,ctx->cert))) 120 { 121 X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE); 122 goto end; 123 } 124 CRYPTO_add(&ctx->cert->references,1,CRYPTO_LOCK_X509); 125 ctx->last_untrusted=1; 126 } 127 128 /* We use a temporary STACK so we can chop and hack at it */ 129 if (ctx->untrusted != NULL 130 && (sktmp=sk_X509_dup(ctx->untrusted)) == NULL) 131 { 132 X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE); 133 goto end; 134 } 135 136 num=sk_X509_num(ctx->chain); 137 x=sk_X509_value(ctx->chain,num-1); 138 depth=param->depth; 139 140 141 for (;;) 142 { 143 /* If we have enough, we break */ 144 if (depth < num) break; /* FIXME: If this happens, we should take 145 * note of it and, if appropriate, use the 146 * X509_V_ERR_CERT_CHAIN_TOO_LONG error 147 * code later. 148 */ 149 150 /* If we are self signed, we break */ 151 if (ctx->check_issued(ctx, x,x)) break; 152 153 /* If we were passed a cert chain, use it first */ 154 if (ctx->untrusted != NULL) 155 { 156 xtmp=find_issuer(ctx, sktmp,x); 157 if (xtmp != NULL) 158 { 159 if (!sk_X509_push(ctx->chain,xtmp)) 160 { 161 X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE); 162 goto end; 163 } 164 CRYPTO_add(&xtmp->references,1,CRYPTO_LOCK_X509); 165 (void)sk_X509_delete_ptr(sktmp,xtmp); 166 ctx->last_untrusted++; 167 x=xtmp; 168 num++; 169 /* reparse the full chain for 170 * the next one */ 171 continue; 172 } 173 } 174 break; 175 } 176 177 /* at this point, chain should contain a list of untrusted 178 * certificates. We now need to add at least one trusted one, 179 * if possible, otherwise we complain. */ 180 181 /* Examine last certificate in chain and see if it 182 * is self signed. 183 */ 184 185 i=sk_X509_num(ctx->chain); 186 x=sk_X509_value(ctx->chain,i-1); 187 if (ctx->check_issued(ctx, x, x)) 188 { 189 /* we have a self signed certificate */ 190 if (sk_X509_num(ctx->chain) == 1) 191 { 192 /* We have a single self signed certificate: see if 193 * we can find it in the store. We must have an exact 194 * match to avoid possible impersonation. 195 */ 196 ok = ctx->get_issuer(&xtmp, ctx, x); 197 if ((ok <= 0) || X509_cmp(x, xtmp)) 198 { 199 ctx->error=X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT; 200 ctx->current_cert=x; 201 ctx->error_depth=i-1; 202 if (ok == 1) X509_free(xtmp); 203 bad_chain = 1; 204 ok=cb(0,ctx); 205 if (!ok) goto end; 206 } 207 else 208 { 209 /* We have a match: replace certificate with store version 210 * so we get any trust settings. 211 */ 212 X509_free(x); 213 x = xtmp; 214 (void)sk_X509_set(ctx->chain, i - 1, x); 215 ctx->last_untrusted=0; 216 } 217 } 218 else 219 { 220 /* extract and save self signed certificate for later use */ 221 chain_ss=sk_X509_pop(ctx->chain); 222 ctx->last_untrusted--; 223 num--; 224 x=sk_X509_value(ctx->chain,num-1); 225 } 226 } 227 228 /* We now lookup certs from the certificate store */ 229 for (;;) 230 { 231 /* If we have enough, we break */ 232 if (depth < num) break; 233 234 /* If we are self signed, we break */ 235 if (ctx->check_issued(ctx,x,x)) break; 236 237 ok = ctx->get_issuer(&xtmp, ctx, x); 238 239 if (ok < 0) return ok; 240 if (ok == 0) break; 241 242 x = xtmp; 243 if (!sk_X509_push(ctx->chain,x)) 244 { 245 X509_free(xtmp); 246 X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE); 247 return 0; 248 } 249 num++; 250 } 251 252 /* we now have our chain, lets check it... */ 253 254 /* Is last certificate looked up self signed? */ 255 if (!ctx->check_issued(ctx,x,x)) 256 { 257 if ((chain_ss == NULL) || !ctx->check_issued(ctx, x, chain_ss)) 258 { 259 if (ctx->last_untrusted >= num) 260 ctx->error=X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY; 261 else 262 ctx->error=X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT; 263 ctx->current_cert=x; 264 } 265 else 266 { 267 268 sk_X509_push(ctx->chain,chain_ss); 269 num++; 270 ctx->last_untrusted=num; 271 ctx->current_cert=chain_ss; 272 ctx->error=X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN; 273 chain_ss=NULL; 274 } 275 276 ctx->error_depth=num-1; 277 bad_chain = 1; 278 ok=cb(0,ctx); 279 if (!ok) goto end; 280 } 281 282 /* We have the chain complete: now we need to check its purpose */ 283 ok = check_chain_extensions(ctx); 284 285 if (!ok) goto end; 286 287 /* The chain extensions are OK: check trust */ 288 289 if (param->trust > 0) ok = check_trust(ctx); 290 291 if (!ok) goto end; 292 293 /* We may as well copy down any DSA parameters that are required */ 294 X509_get_pubkey_parameters(NULL,ctx->chain); 295 296 /* Check revocation status: we do this after copying parameters 297 * because they may be needed for CRL signature verification. 298 */ 299 300 ok = ctx->check_revocation(ctx); 301 if(!ok) goto end; 302 303 /* At this point, we have a chain and need to verify it */ 304 if (ctx->verify != NULL) 305 ok=ctx->verify(ctx); 306 else 307 ok=internal_verify(ctx); 308 if(!ok) goto end; 309 310#ifndef OPENSSL_NO_RFC3779 311 /* RFC 3779 path validation, now that CRL check has been done */ 312 ok = v3_asid_validate_path(ctx); 313 if (!ok) goto end; 314 ok = v3_addr_validate_path(ctx); 315 if (!ok) goto end; 316#endif 317 318 /* If we get this far evaluate policies */ 319 if (!bad_chain && (ctx->param->flags & X509_V_FLAG_POLICY_CHECK)) 320 ok = ctx->check_policy(ctx); 321 if(!ok) goto end; 322 if (0) 323 { 324end: 325 X509_get_pubkey_parameters(NULL,ctx->chain); 326 } 327 if (sktmp != NULL) sk_X509_free(sktmp); 328 if (chain_ss != NULL) X509_free(chain_ss); 329 return ok; 330 } 331 332 333/* Given a STACK_OF(X509) find the issuer of cert (if any) 334 */ 335 336static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x) 337{ 338 int i; 339 X509 *issuer; 340 for (i = 0; i < sk_X509_num(sk); i++) 341 { 342 issuer = sk_X509_value(sk, i); 343 if (ctx->check_issued(ctx, x, issuer)) 344 return issuer; 345 } 346 return NULL; 347} 348 349/* Given a possible certificate and issuer check them */ 350 351static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer) 352{ 353 int ret; 354 ret = X509_check_issued(issuer, x); 355 if (ret == X509_V_OK) 356 return 1; 357 /* If we haven't asked for issuer errors don't set ctx */ 358 if (!(ctx->param->flags & X509_V_FLAG_CB_ISSUER_CHECK)) 359 return 0; 360 361 ctx->error = ret; 362 ctx->current_cert = x; 363 ctx->current_issuer = issuer; 364 return ctx->verify_cb(0, ctx); 365 return 0; 366} 367 368/* Alternative lookup method: look from a STACK stored in other_ctx */ 369 370static int get_issuer_sk(X509 **issuer, X509_STORE_CTX *ctx, X509 *x) 371{ 372 *issuer = find_issuer(ctx, ctx->other_ctx, x); 373 if (*issuer) 374 { 375 CRYPTO_add(&(*issuer)->references,1,CRYPTO_LOCK_X509); 376 return 1; 377 } 378 else 379 return 0; 380} 381 382 383/* Check a certificate chains extensions for consistency 384 * with the supplied purpose 385 */ 386 387static int check_chain_extensions(X509_STORE_CTX *ctx) 388{ 389#ifdef OPENSSL_NO_CHAIN_VERIFY 390 return 1; 391#else 392 int i, ok=0, must_be_ca, plen = 0; 393 X509 *x; 394 int (*cb)(int xok,X509_STORE_CTX *xctx); 395 int proxy_path_length = 0; 396 int allow_proxy_certs = 397 !!(ctx->param->flags & X509_V_FLAG_ALLOW_PROXY_CERTS); 398 cb=ctx->verify_cb; 399 400 /* must_be_ca can have 1 of 3 values: 401 -1: we accept both CA and non-CA certificates, to allow direct 402 use of self-signed certificates (which are marked as CA). 403 0: we only accept non-CA certificates. This is currently not 404 used, but the possibility is present for future extensions. 405 1: we only accept CA certificates. This is currently used for 406 all certificates in the chain except the leaf certificate. 407 */ 408 must_be_ca = -1; 409 410 /* A hack to keep people who don't want to modify their software 411 happy */ 412 if (getenv("OPENSSL_ALLOW_PROXY_CERTS")) 413 allow_proxy_certs = 1; 414 415 /* Check all untrusted certificates */ 416 for (i = 0; i < ctx->last_untrusted; i++) 417 { 418 int ret; 419 x = sk_X509_value(ctx->chain, i); 420 if (!(ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL) 421 && (x->ex_flags & EXFLAG_CRITICAL)) 422 { 423 ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION; 424 ctx->error_depth = i; 425 ctx->current_cert = x; 426 ok=cb(0,ctx); 427 if (!ok) goto end; 428 } 429 if (!allow_proxy_certs && (x->ex_flags & EXFLAG_PROXY)) 430 { 431 ctx->error = X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED; 432 ctx->error_depth = i; 433 ctx->current_cert = x; 434 ok=cb(0,ctx); 435 if (!ok) goto end; 436 } 437 ret = X509_check_ca(x); 438 switch(must_be_ca) 439 { 440 case -1: 441 if ((ctx->param->flags & X509_V_FLAG_X509_STRICT) 442 && (ret != 1) && (ret != 0)) 443 { 444 ret = 0; 445 ctx->error = X509_V_ERR_INVALID_CA; 446 } 447 else 448 ret = 1; 449 break; 450 case 0: 451 if (ret != 0) 452 { 453 ret = 0; 454 ctx->error = X509_V_ERR_INVALID_NON_CA; 455 } 456 else 457 ret = 1; 458 break; 459 default: 460 if ((ret == 0) 461 || ((ctx->param->flags & X509_V_FLAG_X509_STRICT) 462 && (ret != 1))) 463 { 464 ret = 0; 465 ctx->error = X509_V_ERR_INVALID_CA; 466 } 467 else 468 ret = 1; 469 break; 470 } 471 if (ret == 0) 472 { 473 ctx->error_depth = i; 474 ctx->current_cert = x; 475 ok=cb(0,ctx); 476 if (!ok) goto end; 477 } 478 if (ctx->param->purpose > 0) 479 { 480 ret = X509_check_purpose(x, ctx->param->purpose, 481 must_be_ca > 0); 482 if ((ret == 0) 483 || ((ctx->param->flags & X509_V_FLAG_X509_STRICT) 484 && (ret != 1))) 485 { 486 ctx->error = X509_V_ERR_INVALID_PURPOSE; 487 ctx->error_depth = i; 488 ctx->current_cert = x; 489 ok=cb(0,ctx); 490 if (!ok) goto end; 491 } 492 } 493 /* Check pathlen if not self issued */ 494 if ((i > 1) && !(x->ex_flags & EXFLAG_SI) 495 && (x->ex_pathlen != -1) 496 && (plen > (x->ex_pathlen + proxy_path_length + 1))) 497 { 498 ctx->error = X509_V_ERR_PATH_LENGTH_EXCEEDED; 499 ctx->error_depth = i; 500 ctx->current_cert = x; 501 ok=cb(0,ctx); 502 if (!ok) goto end; 503 } 504 /* Increment path length if not self issued */ 505 if (!(x->ex_flags & EXFLAG_SI)) 506 plen++; 507 /* If this certificate is a proxy certificate, the next 508 certificate must be another proxy certificate or a EE 509 certificate. If not, the next certificate must be a 510 CA certificate. */ 511 if (x->ex_flags & EXFLAG_PROXY) 512 { 513 if (x->ex_pcpathlen != -1 && i > x->ex_pcpathlen) 514 { 515 ctx->error = 516 X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED; 517 ctx->error_depth = i; 518 ctx->current_cert = x; 519 ok=cb(0,ctx); 520 if (!ok) goto end; 521 } 522 proxy_path_length++; 523 must_be_ca = 0; 524 } 525 else 526 must_be_ca = 1; 527 } 528 ok = 1; 529 end: 530 return ok; 531#endif 532} 533 534static int check_trust(X509_STORE_CTX *ctx) 535{ 536#ifdef OPENSSL_NO_CHAIN_VERIFY 537 return 1; 538#else 539 int i, ok; 540 X509 *x; 541 int (*cb)(int xok,X509_STORE_CTX *xctx); 542 cb=ctx->verify_cb; 543/* For now just check the last certificate in the chain */ 544 i = sk_X509_num(ctx->chain) - 1; 545 x = sk_X509_value(ctx->chain, i); 546 ok = X509_check_trust(x, ctx->param->trust, 0); 547 if (ok == X509_TRUST_TRUSTED) 548 return 1; 549 ctx->error_depth = i; 550 ctx->current_cert = x; 551 if (ok == X509_TRUST_REJECTED) 552 ctx->error = X509_V_ERR_CERT_REJECTED; 553 else 554 ctx->error = X509_V_ERR_CERT_UNTRUSTED; 555 ok = cb(0, ctx); 556 return ok; 557#endif 558} 559 560static int check_revocation(X509_STORE_CTX *ctx) 561 { 562 int i, last, ok; 563 if (!(ctx->param->flags & X509_V_FLAG_CRL_CHECK)) 564 return 1; 565 if (ctx->param->flags & X509_V_FLAG_CRL_CHECK_ALL) 566 last = sk_X509_num(ctx->chain) - 1; 567 else 568 last = 0; 569 for(i = 0; i <= last; i++) 570 { 571 ctx->error_depth = i; 572 ok = check_cert(ctx); 573 if (!ok) return ok; 574 } 575 return 1; 576 } 577 578static int check_cert(X509_STORE_CTX *ctx) 579 { 580 X509_CRL *crl = NULL; 581 X509 *x; 582 int ok, cnum; 583 cnum = ctx->error_depth; 584 x = sk_X509_value(ctx->chain, cnum); 585 ctx->current_cert = x; 586 /* Try to retrieve relevant CRL */ 587 ok = ctx->get_crl(ctx, &crl, x); 588 /* If error looking up CRL, nothing we can do except 589 * notify callback 590 */ 591 if(!ok) 592 { 593 ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL; 594 ok = ctx->verify_cb(0, ctx); 595 goto err; 596 } 597 ctx->current_crl = crl; 598 ok = ctx->check_crl(ctx, crl); 599 if (!ok) goto err; 600 ok = ctx->cert_crl(ctx, crl, x); 601 err: 602 ctx->current_crl = NULL; 603 X509_CRL_free(crl); 604 return ok; 605 606 } 607 608/* Check CRL times against values in X509_STORE_CTX */ 609 610static int check_crl_time(X509_STORE_CTX *ctx, X509_CRL *crl, int notify) 611 { 612 time_t *ptime; 613 int i; 614 ctx->current_crl = crl; 615 if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME) 616 ptime = &ctx->param->check_time; 617 else 618 ptime = NULL; 619 620 i=X509_cmp_time(X509_CRL_get_lastUpdate(crl), ptime); 621 if (i == 0) 622 { 623 ctx->error=X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD; 624 if (!notify || !ctx->verify_cb(0, ctx)) 625 return 0; 626 } 627 628 if (i > 0) 629 { 630 ctx->error=X509_V_ERR_CRL_NOT_YET_VALID; 631 if (!notify || !ctx->verify_cb(0, ctx)) 632 return 0; 633 } 634 635 if(X509_CRL_get_nextUpdate(crl)) 636 { 637 i=X509_cmp_time(X509_CRL_get_nextUpdate(crl), ptime); 638 639 if (i == 0) 640 { 641 ctx->error=X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD; 642 if (!notify || !ctx->verify_cb(0, ctx)) 643 return 0; 644 } 645 646 if (i < 0) 647 { 648 ctx->error=X509_V_ERR_CRL_HAS_EXPIRED; 649 if (!notify || !ctx->verify_cb(0, ctx)) 650 return 0; 651 } 652 } 653 654 ctx->current_crl = NULL; 655 656 return 1; 657 } 658 659/* Lookup CRLs from the supplied list. Look for matching isser name 660 * and validity. If we can't find a valid CRL return the last one 661 * with matching name. This gives more meaningful error codes. Otherwise 662 * we'd get a CRL not found error if a CRL existed with matching name but 663 * was invalid. 664 */ 665 666static int get_crl_sk(X509_STORE_CTX *ctx, X509_CRL **pcrl, 667 X509_NAME *nm, STACK_OF(X509_CRL) *crls) 668 { 669 int i; 670 X509_CRL *crl, *best_crl = NULL; 671 for (i = 0; i < sk_X509_CRL_num(crls); i++) 672 { 673 crl = sk_X509_CRL_value(crls, i); 674 if (X509_NAME_cmp(nm, X509_CRL_get_issuer(crl))) 675 continue; 676 if (check_crl_time(ctx, crl, 0)) 677 { 678 *pcrl = crl; 679 CRYPTO_add(&crl->references, 1, CRYPTO_LOCK_X509); 680 return 1; 681 } 682 best_crl = crl; 683 } 684 if (best_crl) 685 { 686 *pcrl = best_crl; 687 CRYPTO_add(&best_crl->references, 1, CRYPTO_LOCK_X509); 688 } 689 690 return 0; 691 } 692 693/* Retrieve CRL corresponding to certificate: currently just a 694 * subject lookup: maybe use AKID later... 695 */ 696static int get_crl(X509_STORE_CTX *ctx, X509_CRL **pcrl, X509 *x) 697 { 698 int ok; 699 X509_CRL *crl = NULL; 700 X509_OBJECT xobj; 701 X509_NAME *nm; 702 nm = X509_get_issuer_name(x); 703 ok = get_crl_sk(ctx, &crl, nm, ctx->crls); 704 if (ok) 705 { 706 *pcrl = crl; 707 return 1; 708 } 709 710 ok = X509_STORE_get_by_subject(ctx, X509_LU_CRL, nm, &xobj); 711 712 if (!ok) 713 { 714 /* If we got a near match from get_crl_sk use that */ 715 if (crl) 716 { 717 *pcrl = crl; 718 return 1; 719 } 720 return 0; 721 } 722 723 *pcrl = xobj.data.crl; 724 if (crl) 725 X509_CRL_free(crl); 726 return 1; 727 } 728 729/* Check CRL validity */ 730static int check_crl(X509_STORE_CTX *ctx, X509_CRL *crl) 731 { 732 X509 *issuer = NULL; 733 EVP_PKEY *ikey = NULL; 734 int ok = 0, chnum, cnum; 735 cnum = ctx->error_depth; 736 chnum = sk_X509_num(ctx->chain) - 1; 737 /* Find CRL issuer: if not last certificate then issuer 738 * is next certificate in chain. 739 */ 740 if(cnum < chnum) 741 issuer = sk_X509_value(ctx->chain, cnum + 1); 742 else 743 { 744 issuer = sk_X509_value(ctx->chain, chnum); 745 /* If not self signed, can't check signature */ 746 if(!ctx->check_issued(ctx, issuer, issuer)) 747 { 748 ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER; 749 ok = ctx->verify_cb(0, ctx); 750 if(!ok) goto err; 751 } 752 } 753 754 if(issuer) 755 { 756 /* Check for cRLSign bit if keyUsage present */ 757 if ((issuer->ex_flags & EXFLAG_KUSAGE) && 758 !(issuer->ex_kusage & KU_CRL_SIGN)) 759 { 760 ctx->error = X509_V_ERR_KEYUSAGE_NO_CRL_SIGN; 761 ok = ctx->verify_cb(0, ctx); 762 if(!ok) goto err; 763 } 764 765 /* Attempt to get issuer certificate public key */ 766 ikey = X509_get_pubkey(issuer); 767 768 if(!ikey) 769 { 770 ctx->error=X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY; 771 ok = ctx->verify_cb(0, ctx); 772 if (!ok) goto err; 773 } 774 else 775 { 776 /* Verify CRL signature */ 777 if(X509_CRL_verify(crl, ikey) <= 0) 778 { 779 ctx->error=X509_V_ERR_CRL_SIGNATURE_FAILURE; 780 ok = ctx->verify_cb(0, ctx); 781 if (!ok) goto err; 782 } 783 } 784 } 785 786 ok = check_crl_time(ctx, crl, 1); 787 if (!ok) 788 goto err; 789 790 ok = 1; 791 792 err: 793 EVP_PKEY_free(ikey); 794 return ok; 795 } 796 797/* Check certificate against CRL */ 798static int cert_crl(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x) 799 { 800 int idx, ok; 801 X509_REVOKED rtmp; 802 STACK_OF(X509_EXTENSION) *exts; 803 X509_EXTENSION *ext; 804 /* Look for serial number of certificate in CRL */ 805 rtmp.serialNumber = X509_get_serialNumber(x); 806 /* Sort revoked into serial number order if not already sorted. 807 * Do this under a lock to avoid race condition. 808 */ 809 if (!sk_X509_REVOKED_is_sorted(crl->crl->revoked)) 810 { 811 CRYPTO_w_lock(CRYPTO_LOCK_X509_CRL); 812 sk_X509_REVOKED_sort(crl->crl->revoked); 813 CRYPTO_w_unlock(CRYPTO_LOCK_X509_CRL); 814 } 815 idx = sk_X509_REVOKED_find(crl->crl->revoked, &rtmp); 816 /* If found assume revoked: want something cleverer than 817 * this to handle entry extensions in V2 CRLs. 818 */ 819 if(idx >= 0) 820 { 821 ctx->error = X509_V_ERR_CERT_REVOKED; 822 ok = ctx->verify_cb(0, ctx); 823 if (!ok) return 0; 824 } 825 826 if (ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL) 827 return 1; 828 829 /* See if we have any critical CRL extensions: since we 830 * currently don't handle any CRL extensions the CRL must be 831 * rejected. 832 * This code accesses the X509_CRL structure directly: applications 833 * shouldn't do this. 834 */ 835 836 exts = crl->crl->extensions; 837 838 for (idx = 0; idx < sk_X509_EXTENSION_num(exts); idx++) 839 { 840 ext = sk_X509_EXTENSION_value(exts, idx); 841 if (ext->critical > 0) 842 { 843 ctx->error = 844 X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION; 845 ok = ctx->verify_cb(0, ctx); 846 if(!ok) return 0; 847 break; 848 } 849 } 850 return 1; 851 } 852 853static int check_policy(X509_STORE_CTX *ctx) 854 { 855 int ret; 856 ret = X509_policy_check(&ctx->tree, &ctx->explicit_policy, ctx->chain, 857 ctx->param->policies, ctx->param->flags); 858 if (ret == 0) 859 { 860 X509err(X509_F_CHECK_POLICY,ERR_R_MALLOC_FAILURE); 861 return 0; 862 } 863 /* Invalid or inconsistent extensions */ 864 if (ret == -1) 865 { 866 /* Locate certificates with bad extensions and notify 867 * callback. 868 */ 869 X509 *x; 870 int i; 871 for (i = 1; i < sk_X509_num(ctx->chain); i++) 872 { 873 x = sk_X509_value(ctx->chain, i); 874 if (!(x->ex_flags & EXFLAG_INVALID_POLICY)) 875 continue; 876 ctx->current_cert = x; 877 ctx->error = X509_V_ERR_INVALID_POLICY_EXTENSION; 878 ret = ctx->verify_cb(0, ctx); 879 } 880 return 1; 881 } 882 if (ret == -2) 883 { 884 ctx->current_cert = NULL; 885 ctx->error = X509_V_ERR_NO_EXPLICIT_POLICY; 886 return ctx->verify_cb(0, ctx); 887 } 888 889 if (ctx->param->flags & X509_V_FLAG_NOTIFY_POLICY) 890 { 891 ctx->current_cert = NULL; 892 ctx->error = X509_V_OK; 893 if (!ctx->verify_cb(2, ctx)) 894 return 0; 895 } 896 897 return 1; 898 } 899 900static int check_cert_time(X509_STORE_CTX *ctx, X509 *x) 901 { 902 time_t *ptime; 903 int i; 904 905 if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME) 906 ptime = &ctx->param->check_time; 907 else 908 ptime = NULL; 909 910 i=X509_cmp_time(X509_get_notBefore(x), ptime); 911 if (i == 0) 912 { 913 ctx->error=X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD; 914 ctx->current_cert=x; 915 if (!ctx->verify_cb(0, ctx)) 916 return 0; 917 } 918 919 if (i > 0) 920 { 921 ctx->error=X509_V_ERR_CERT_NOT_YET_VALID; 922 ctx->current_cert=x; 923 if (!ctx->verify_cb(0, ctx)) 924 return 0; 925 } 926 927 i=X509_cmp_time(X509_get_notAfter(x), ptime); 928 if (i == 0) 929 { 930 ctx->error=X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD; 931 ctx->current_cert=x; 932 if (!ctx->verify_cb(0, ctx)) 933 return 0; 934 } 935 936 if (i < 0) 937 { 938 ctx->error=X509_V_ERR_CERT_HAS_EXPIRED; 939 ctx->current_cert=x; 940 if (!ctx->verify_cb(0, ctx)) 941 return 0; 942 } 943 944 return 1; 945 } 946 947static int internal_verify(X509_STORE_CTX *ctx) 948 { 949 int ok=0,n; 950 X509 *xs,*xi; 951 EVP_PKEY *pkey=NULL; 952 int (*cb)(int xok,X509_STORE_CTX *xctx); 953 954 cb=ctx->verify_cb; 955 956 n=sk_X509_num(ctx->chain); 957 ctx->error_depth=n-1; 958 n--; 959 xi=sk_X509_value(ctx->chain,n); 960 961 if (ctx->check_issued(ctx, xi, xi)) 962 xs=xi; 963 else 964 { 965 if (n <= 0) 966 { 967 ctx->error=X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE; 968 ctx->current_cert=xi; 969 ok=cb(0,ctx); 970 goto end; 971 } 972 else 973 { 974 n--; 975 ctx->error_depth=n; 976 xs=sk_X509_value(ctx->chain,n); 977 } 978 } 979 980/* ctx->error=0; not needed */ 981 while (n >= 0) 982 { 983 ctx->error_depth=n; 984 985 /* Skip signature check for self signed certificates unless 986 * explicitly asked for. It doesn't add any security and 987 * just wastes time. 988 */ 989 if (!xs->valid && (xs != xi || (ctx->param->flags & X509_V_FLAG_CHECK_SS_SIGNATURE))) 990 { 991 if ((pkey=X509_get_pubkey(xi)) == NULL) 992 { 993 ctx->error=X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY; 994 ctx->current_cert=xi; 995 ok=(*cb)(0,ctx); 996 if (!ok) goto end; 997 } 998 else if (X509_verify(xs,pkey) <= 0) 999 { 1000 ctx->error=X509_V_ERR_CERT_SIGNATURE_FAILURE; 1001 ctx->current_cert=xs; 1002 ok=(*cb)(0,ctx); 1003 if (!ok) 1004 { 1005 EVP_PKEY_free(pkey); 1006 goto end; 1007 } 1008 } 1009 EVP_PKEY_free(pkey); 1010 pkey=NULL; 1011 } 1012 1013 xs->valid = 1; 1014 1015 ok = check_cert_time(ctx, xs); 1016 if (!ok) 1017 goto end; 1018 1019 /* The last error (if any) is still in the error value */ 1020 ctx->current_issuer=xi; 1021 ctx->current_cert=xs; 1022 ok=(*cb)(1,ctx); 1023 if (!ok) goto end; 1024 1025 n--; 1026 if (n >= 0) 1027 { 1028 xi=xs; 1029 xs=sk_X509_value(ctx->chain,n); 1030 } 1031 } 1032 ok=1; 1033end: 1034 return ok; 1035 } 1036 1037int X509_cmp_current_time(ASN1_TIME *ctm) 1038{ 1039 return X509_cmp_time(ctm, NULL); 1040} 1041 1042int X509_cmp_time(ASN1_TIME *ctm, time_t *cmp_time) 1043{ 1044 char *str; 1045 ASN1_TIME atm; 1046 long offset; 1047 char buff1[24], buff2[24], *p; 1048 int i, j, remaining; 1049 1050 p = buff1; 1051 remaining = ctm->length; 1052 str = (char *)ctm->data; 1053 /* 1054 * Note that the following (historical) code allows much more slack in the 1055 * time format than RFC5280. In RFC5280, the representation is fixed: 1056 * UTCTime: YYMMDDHHMMSSZ 1057 * GeneralizedTime: YYYYMMDDHHMMSSZ 1058 */ 1059 if (ctm->type == V_ASN1_UTCTIME) { 1060 /* YYMMDDHHMM[SS]Z or YYMMDDHHMM[SS](+-)hhmm */ 1061 int min_length = sizeof("YYMMDDHHMMZ") - 1; 1062 int max_length = sizeof("YYMMDDHHMMSS+hhmm") - 1; 1063 if (remaining < min_length || remaining > max_length) 1064 return 0; 1065 memcpy(p, str, 10); 1066 p += 10; 1067 str += 10; 1068 remaining -= 10; 1069 } else { 1070 /* YYYYMMDDHHMM[SS[.fff]]Z or YYYYMMDDHHMM[SS[.f[f[f]]]](+-)hhmm */ 1071 int min_length = sizeof("YYYYMMDDHHMMZ") - 1; 1072 int max_length = sizeof("YYYYMMDDHHMMSS.fff+hhmm") - 1; 1073 if (remaining < min_length || remaining > max_length) 1074 return 0; 1075 memcpy(p, str, 12); 1076 p += 12; 1077 str += 12; 1078 remaining -= 12; 1079 } 1080 1081 if ((*str == 'Z') || (*str == '-') || (*str == '+')) { 1082 *(p++) = '0'; 1083 *(p++) = '0'; 1084 } else { 1085 /* SS (seconds) */ 1086 if (remaining < 2) 1087 return 0; 1088 *(p++) = *(str++); 1089 *(p++) = *(str++); 1090 remaining -= 2; 1091 /* 1092 * Skip any (up to three) fractional seconds... 1093 * TODO(emilia): in RFC5280, fractional seconds are forbidden. 1094 * Can we just kill them altogether? 1095 */ 1096 if (remaining && *str == '.') { 1097 str++; 1098 remaining--; 1099 for (i = 0; i < 3 && remaining; i++, str++, remaining--) { 1100 if (*str < '0' || *str > '9') 1101 break; 1102 } 1103 } 1104 1105 } 1106 *(p++) = 'Z'; 1107 *(p++) = '\0'; 1108 1109 /* We now need either a terminating 'Z' or an offset. */ 1110 if (!remaining) 1111 return 0; 1112 if (*str == 'Z') { 1113 if (remaining != 1) 1114 return 0; 1115 offset = 0; 1116 } else { 1117 /* (+-)HHMM */ 1118 if ((*str != '+') && (*str != '-')) 1119 return 0; 1120 /* Historical behaviour: the (+-)hhmm offset is forbidden in RFC5280. */ 1121 if (remaining != 5) 1122 return 0; 1123 if (str[1] < '0' || str[1] > '9' || str[2] < '0' || str[2] > '9' || 1124 str[3] < '0' || str[3] > '9' || str[4] < '0' || str[4] > '9') 1125 return 0; 1126 offset = ((str[1] - '0') * 10 + (str[2] - '0')) * 60; 1127 offset += (str[3] - '0') * 10 + (str[4] - '0'); 1128 if (*str == '-') 1129 offset = -offset; 1130 } 1131 atm.type = ctm->type; 1132 atm.length = sizeof(buff2); 1133 atm.data = (unsigned char *)buff2; 1134 1135 if (X509_time_adj(&atm, offset * 60, cmp_time) == NULL) 1136 return 0; 1137 1138 if (ctm->type == V_ASN1_UTCTIME) { 1139 i = (buff1[0] - '0') * 10 + (buff1[1] - '0'); 1140 if (i < 50) 1141 i += 100; /* cf. RFC 2459 */ 1142 j = (buff2[0] - '0') * 10 + (buff2[1] - '0'); 1143 if (j < 50) 1144 j += 100; 1145 1146 if (i < j) 1147 return -1; 1148 if (i > j) 1149 return 1; 1150 } 1151 i = strcmp(buff1, buff2); 1152 if (i == 0) /* wait a second then return younger :-) */ 1153 return -1; 1154 else 1155 return i; 1156} 1157 1158ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj) 1159{ 1160 return X509_time_adj(s, adj, NULL); 1161} 1162 1163ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *in_tm) 1164 { 1165 time_t t; 1166 int type = -1; 1167 1168 if (in_tm) t = *in_tm; 1169 else time(&t); 1170 1171 t+=adj; 1172 if (s) type = s->type; 1173 if (type == V_ASN1_UTCTIME) return ASN1_UTCTIME_set(s,t); 1174 if (type == V_ASN1_GENERALIZEDTIME) return ASN1_GENERALIZEDTIME_set(s, t); 1175 return ASN1_TIME_set(s, t); 1176 } 1177 1178int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain) 1179 { 1180 EVP_PKEY *ktmp=NULL,*ktmp2; 1181 int i,j; 1182 1183 if ((pkey != NULL) && !EVP_PKEY_missing_parameters(pkey)) return 1; 1184 1185 for (i=0; i<sk_X509_num(chain); i++) 1186 { 1187 ktmp=X509_get_pubkey(sk_X509_value(chain,i)); 1188 if (ktmp == NULL) 1189 { 1190 X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY); 1191 return 0; 1192 } 1193 if (!EVP_PKEY_missing_parameters(ktmp)) 1194 break; 1195 else 1196 { 1197 EVP_PKEY_free(ktmp); 1198 ktmp=NULL; 1199 } 1200 } 1201 if (ktmp == NULL) 1202 { 1203 X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN); 1204 return 0; 1205 } 1206 1207 /* first, populate the other certs */ 1208 for (j=i-1; j >= 0; j--) 1209 { 1210 ktmp2=X509_get_pubkey(sk_X509_value(chain,j)); 1211 EVP_PKEY_copy_parameters(ktmp2,ktmp); 1212 EVP_PKEY_free(ktmp2); 1213 } 1214 1215 if (pkey != NULL) EVP_PKEY_copy_parameters(pkey,ktmp); 1216 EVP_PKEY_free(ktmp); 1217 return 1; 1218 } 1219 1220int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, 1221 CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) 1222 { 1223 /* This function is (usually) called only once, by 1224 * SSL_get_ex_data_X509_STORE_CTX_idx (ssl/ssl_cert.c). */ 1225 return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, argl, argp, 1226 new_func, dup_func, free_func); 1227 } 1228 1229int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data) 1230 { 1231 return CRYPTO_set_ex_data(&ctx->ex_data,idx,data); 1232 } 1233 1234void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx) 1235 { 1236 return CRYPTO_get_ex_data(&ctx->ex_data,idx); 1237 } 1238 1239int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx) 1240 { 1241 return ctx->error; 1242 } 1243 1244void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err) 1245 { 1246 ctx->error=err; 1247 } 1248 1249int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx) 1250 { 1251 return ctx->error_depth; 1252 } 1253 1254X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx) 1255 { 1256 return ctx->current_cert; 1257 } 1258 1259STACK_OF(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx) 1260 { 1261 return ctx->chain; 1262 } 1263 1264STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx) 1265 { 1266 int i; 1267 X509 *x; 1268 STACK_OF(X509) *chain; 1269 if (!ctx->chain || !(chain = sk_X509_dup(ctx->chain))) return NULL; 1270 for (i = 0; i < sk_X509_num(chain); i++) 1271 { 1272 x = sk_X509_value(chain, i); 1273 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509); 1274 } 1275 return chain; 1276 } 1277 1278void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x) 1279 { 1280 ctx->cert=x; 1281 } 1282 1283void X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk) 1284 { 1285 ctx->untrusted=sk; 1286 } 1287 1288void X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk) 1289 { 1290 ctx->crls=sk; 1291 } 1292 1293int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose) 1294 { 1295 return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0); 1296 } 1297 1298int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust) 1299 { 1300 return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust); 1301 } 1302 1303/* This function is used to set the X509_STORE_CTX purpose and trust 1304 * values. This is intended to be used when another structure has its 1305 * own trust and purpose values which (if set) will be inherited by 1306 * the ctx. If they aren't set then we will usually have a default 1307 * purpose in mind which should then be used to set the trust value. 1308 * An example of this is SSL use: an SSL structure will have its own 1309 * purpose and trust settings which the application can set: if they 1310 * aren't set then we use the default of SSL client/server. 1311 */ 1312 1313int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose, 1314 int purpose, int trust) 1315{ 1316 int idx; 1317 /* If purpose not set use default */ 1318 if (!purpose) purpose = def_purpose; 1319 /* If we have a purpose then check it is valid */ 1320 if (purpose) 1321 { 1322 X509_PURPOSE *ptmp; 1323 idx = X509_PURPOSE_get_by_id(purpose); 1324 if (idx == -1) 1325 { 1326 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT, 1327 X509_R_UNKNOWN_PURPOSE_ID); 1328 return 0; 1329 } 1330 ptmp = X509_PURPOSE_get0(idx); 1331 if (ptmp->trust == X509_TRUST_DEFAULT) 1332 { 1333 idx = X509_PURPOSE_get_by_id(def_purpose); 1334 if (idx == -1) 1335 { 1336 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT, 1337 X509_R_UNKNOWN_PURPOSE_ID); 1338 return 0; 1339 } 1340 ptmp = X509_PURPOSE_get0(idx); 1341 } 1342 /* If trust not set then get from purpose default */ 1343 if (!trust) trust = ptmp->trust; 1344 } 1345 if (trust) 1346 { 1347 idx = X509_TRUST_get_by_id(trust); 1348 if (idx == -1) 1349 { 1350 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT, 1351 X509_R_UNKNOWN_TRUST_ID); 1352 return 0; 1353 } 1354 } 1355 1356 if (purpose && !ctx->param->purpose) ctx->param->purpose = purpose; 1357 if (trust && !ctx->param->trust) ctx->param->trust = trust; 1358 return 1; 1359} 1360 1361X509_STORE_CTX *X509_STORE_CTX_new(void) 1362{ 1363 X509_STORE_CTX *ctx; 1364 ctx = (X509_STORE_CTX *)OPENSSL_malloc(sizeof(X509_STORE_CTX)); 1365 if (!ctx) 1366 { 1367 X509err(X509_F_X509_STORE_CTX_NEW,ERR_R_MALLOC_FAILURE); 1368 return NULL; 1369 } 1370 memset(ctx, 0, sizeof(X509_STORE_CTX)); 1371 return ctx; 1372} 1373 1374void X509_STORE_CTX_free(X509_STORE_CTX *ctx) 1375{ 1376 X509_STORE_CTX_cleanup(ctx); 1377 OPENSSL_free(ctx); 1378} 1379 1380int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, 1381 STACK_OF(X509) *chain) 1382 { 1383 int ret = 1; 1384 ctx->ctx=store; 1385 ctx->current_method=0; 1386 ctx->cert=x509; 1387 ctx->untrusted=chain; 1388 ctx->crls = NULL; 1389 ctx->last_untrusted=0; 1390 ctx->other_ctx=NULL; 1391 ctx->valid=0; 1392 ctx->chain=NULL; 1393 ctx->error=0; 1394 ctx->explicit_policy=0; 1395 ctx->error_depth=0; 1396 ctx->current_cert=NULL; 1397 ctx->current_issuer=NULL; 1398 ctx->tree = NULL; 1399 1400 ctx->param = X509_VERIFY_PARAM_new(); 1401 1402 if (!ctx->param) 1403 { 1404 X509err(X509_F_X509_STORE_CTX_INIT,ERR_R_MALLOC_FAILURE); 1405 return 0; 1406 } 1407 1408 /* Inherit callbacks and flags from X509_STORE if not set 1409 * use defaults. 1410 */ 1411 1412 1413 if (store) 1414 ret = X509_VERIFY_PARAM_inherit(ctx->param, store->param); 1415 else 1416 ctx->param->inh_flags |= X509_VP_FLAG_DEFAULT|X509_VP_FLAG_ONCE; 1417 1418 if (store) 1419 { 1420 ctx->verify_cb = store->verify_cb; 1421 ctx->cleanup = store->cleanup; 1422 } 1423 else 1424 ctx->cleanup = 0; 1425 1426 if (ret) 1427 ret = X509_VERIFY_PARAM_inherit(ctx->param, 1428 X509_VERIFY_PARAM_lookup("default")); 1429 1430 if (ret == 0) 1431 { 1432 X509err(X509_F_X509_STORE_CTX_INIT,ERR_R_MALLOC_FAILURE); 1433 return 0; 1434 } 1435 1436 if (store && store->check_issued) 1437 ctx->check_issued = store->check_issued; 1438 else 1439 ctx->check_issued = check_issued; 1440 1441 if (store && store->get_issuer) 1442 ctx->get_issuer = store->get_issuer; 1443 else 1444 ctx->get_issuer = X509_STORE_CTX_get1_issuer; 1445 1446 if (store && store->verify_cb) 1447 ctx->verify_cb = store->verify_cb; 1448 else 1449 ctx->verify_cb = null_callback; 1450 1451 if (store && store->verify) 1452 ctx->verify = store->verify; 1453 else 1454 ctx->verify = internal_verify; 1455 1456 if (store && store->check_revocation) 1457 ctx->check_revocation = store->check_revocation; 1458 else 1459 ctx->check_revocation = check_revocation; 1460 1461 if (store && store->get_crl) 1462 ctx->get_crl = store->get_crl; 1463 else 1464 ctx->get_crl = get_crl; 1465 1466 if (store && store->check_crl) 1467 ctx->check_crl = store->check_crl; 1468 else 1469 ctx->check_crl = check_crl; 1470 1471 if (store && store->cert_crl) 1472 ctx->cert_crl = store->cert_crl; 1473 else 1474 ctx->cert_crl = cert_crl; 1475 1476 ctx->check_policy = check_policy; 1477 1478 1479 /* This memset() can't make any sense anyway, so it's removed. As 1480 * X509_STORE_CTX_cleanup does a proper "free" on the ex_data, we put a 1481 * corresponding "new" here and remove this bogus initialisation. */ 1482 /* memset(&(ctx->ex_data),0,sizeof(CRYPTO_EX_DATA)); */ 1483 if(!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx, 1484 &(ctx->ex_data))) 1485 { 1486 OPENSSL_free(ctx); 1487 X509err(X509_F_X509_STORE_CTX_INIT,ERR_R_MALLOC_FAILURE); 1488 return 0; 1489 } 1490 return 1; 1491 } 1492 1493/* Set alternative lookup method: just a STACK of trusted certificates. 1494 * This avoids X509_STORE nastiness where it isn't needed. 1495 */ 1496 1497void X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk) 1498{ 1499 ctx->other_ctx = sk; 1500 ctx->get_issuer = get_issuer_sk; 1501} 1502 1503void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx) 1504 { 1505 if (ctx->cleanup) ctx->cleanup(ctx); 1506 if (ctx->param != NULL) 1507 { 1508 X509_VERIFY_PARAM_free(ctx->param); 1509 ctx->param=NULL; 1510 } 1511 if (ctx->tree != NULL) 1512 { 1513 X509_policy_tree_free(ctx->tree); 1514 ctx->tree=NULL; 1515 } 1516 if (ctx->chain != NULL) 1517 { 1518 sk_X509_pop_free(ctx->chain,X509_free); 1519 ctx->chain=NULL; 1520 } 1521 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx, &(ctx->ex_data)); 1522 memset(&ctx->ex_data,0,sizeof(CRYPTO_EX_DATA)); 1523 } 1524 1525void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth) 1526 { 1527 X509_VERIFY_PARAM_set_depth(ctx->param, depth); 1528 } 1529 1530void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags) 1531 { 1532 X509_VERIFY_PARAM_set_flags(ctx->param, flags); 1533 } 1534 1535void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, time_t t) 1536 { 1537 X509_VERIFY_PARAM_set_time(ctx->param, t); 1538 } 1539 1540void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx, 1541 int (*verify_cb)(int, X509_STORE_CTX *)) 1542 { 1543 ctx->verify_cb=verify_cb; 1544 } 1545 1546X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx) 1547 { 1548 return ctx->tree; 1549 } 1550 1551int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx) 1552 { 1553 return ctx->explicit_policy; 1554 } 1555 1556int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name) 1557 { 1558 const X509_VERIFY_PARAM *param; 1559 param = X509_VERIFY_PARAM_lookup(name); 1560 if (!param) 1561 return 0; 1562 return X509_VERIFY_PARAM_inherit(ctx->param, param); 1563 } 1564 1565X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx) 1566 { 1567 return ctx->param; 1568 } 1569 1570void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param) 1571 { 1572 if (ctx->param) 1573 X509_VERIFY_PARAM_free(ctx->param); 1574 ctx->param = param; 1575 } 1576 1577IMPLEMENT_STACK_OF(X509) 1578IMPLEMENT_ASN1_SET_OF(X509) 1579 1580IMPLEMENT_STACK_OF(X509_NAME) 1581 1582IMPLEMENT_STACK_OF(X509_ATTRIBUTE) 1583IMPLEMENT_ASN1_SET_OF(X509_ATTRIBUTE) 1584