x509_vfy.c revision 337982
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 <ctype.h> 60#include <stdio.h> 61#include <time.h> 62#include <errno.h> 63 64#include "cryptlib.h" 65#include <openssl/crypto.h> 66#include <openssl/lhash.h> 67#include <openssl/buffer.h> 68#include <openssl/evp.h> 69#include <openssl/asn1.h> 70#include <openssl/x509.h> 71#include <openssl/x509v3.h> 72#include <openssl/objects.h> 73#include "vpm_int.h" 74 75/* CRL score values */ 76 77/* No unhandled critical extensions */ 78 79#define CRL_SCORE_NOCRITICAL 0x100 80 81/* certificate is within CRL scope */ 82 83#define CRL_SCORE_SCOPE 0x080 84 85/* CRL times valid */ 86 87#define CRL_SCORE_TIME 0x040 88 89/* Issuer name matches certificate */ 90 91#define CRL_SCORE_ISSUER_NAME 0x020 92 93/* If this score or above CRL is probably valid */ 94 95#define CRL_SCORE_VALID (CRL_SCORE_NOCRITICAL|CRL_SCORE_TIME|CRL_SCORE_SCOPE) 96 97/* CRL issuer is certificate issuer */ 98 99#define CRL_SCORE_ISSUER_CERT 0x018 100 101/* CRL issuer is on certificate path */ 102 103#define CRL_SCORE_SAME_PATH 0x008 104 105/* CRL issuer matches CRL AKID */ 106 107#define CRL_SCORE_AKID 0x004 108 109/* Have a delta CRL with valid times */ 110 111#define CRL_SCORE_TIME_DELTA 0x002 112 113static int null_callback(int ok, X509_STORE_CTX *e); 114static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer); 115static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x); 116static int check_chain_extensions(X509_STORE_CTX *ctx); 117static int check_name_constraints(X509_STORE_CTX *ctx); 118static int check_id(X509_STORE_CTX *ctx); 119static int check_trust(X509_STORE_CTX *ctx); 120static int check_revocation(X509_STORE_CTX *ctx); 121static int check_cert(X509_STORE_CTX *ctx); 122static int check_policy(X509_STORE_CTX *ctx); 123 124static int get_crl_score(X509_STORE_CTX *ctx, X509 **pissuer, 125 unsigned int *preasons, X509_CRL *crl, X509 *x); 126static int get_crl_delta(X509_STORE_CTX *ctx, 127 X509_CRL **pcrl, X509_CRL **pdcrl, X509 *x); 128static void get_delta_sk(X509_STORE_CTX *ctx, X509_CRL **dcrl, 129 int *pcrl_score, X509_CRL *base, 130 STACK_OF(X509_CRL) *crls); 131static void crl_akid_check(X509_STORE_CTX *ctx, X509_CRL *crl, X509 **pissuer, 132 int *pcrl_score); 133static int crl_crldp_check(X509 *x, X509_CRL *crl, int crl_score, 134 unsigned int *preasons); 135static int check_crl_path(X509_STORE_CTX *ctx, X509 *x); 136static int check_crl_chain(X509_STORE_CTX *ctx, 137 STACK_OF(X509) *cert_path, 138 STACK_OF(X509) *crl_path); 139 140static int internal_verify(X509_STORE_CTX *ctx); 141const char X509_version[] = "X.509" OPENSSL_VERSION_PTEXT; 142 143static int null_callback(int ok, X509_STORE_CTX *e) 144{ 145 return ok; 146} 147 148#if 0 149static int x509_subject_cmp(X509 **a, X509 **b) 150{ 151 return X509_subject_name_cmp(*a, *b); 152} 153#endif 154/* Return 1 is a certificate is self signed */ 155static int cert_self_signed(X509 *x) 156{ 157 X509_check_purpose(x, -1, 0); 158 if (x->ex_flags & EXFLAG_SS) 159 return 1; 160 else 161 return 0; 162} 163 164/* Given a certificate try and find an exact match in the store */ 165 166static X509 *lookup_cert_match(X509_STORE_CTX *ctx, X509 *x) 167{ 168 STACK_OF(X509) *certs; 169 X509 *xtmp = NULL; 170 int i; 171 /* Lookup all certs with matching subject name */ 172 certs = ctx->lookup_certs(ctx, X509_get_subject_name(x)); 173 if (certs == NULL) 174 return NULL; 175 /* Look for exact match */ 176 for (i = 0; i < sk_X509_num(certs); i++) { 177 xtmp = sk_X509_value(certs, i); 178 if (!X509_cmp(xtmp, x)) 179 break; 180 } 181 if (i < sk_X509_num(certs)) 182 CRYPTO_add(&xtmp->references, 1, CRYPTO_LOCK_X509); 183 else 184 xtmp = NULL; 185 sk_X509_pop_free(certs, X509_free); 186 return xtmp; 187} 188 189int X509_verify_cert(X509_STORE_CTX *ctx) 190{ 191 X509 *x, *xtmp, *xtmp2, *chain_ss = NULL; 192 int bad_chain = 0; 193 X509_VERIFY_PARAM *param = ctx->param; 194 int depth, i, ok = 0; 195 int num, j, retry; 196 int (*cb) (int xok, X509_STORE_CTX *xctx); 197 STACK_OF(X509) *sktmp = NULL; 198 int trust = X509_TRUST_UNTRUSTED; 199 int err; 200 201 if (ctx->cert == NULL) { 202 X509err(X509_F_X509_VERIFY_CERT, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY); 203 ctx->error = X509_V_ERR_INVALID_CALL; 204 return -1; 205 } 206 if (ctx->chain != NULL) { 207 /* 208 * This X509_STORE_CTX has already been used to verify a cert. We 209 * cannot do another one. 210 */ 211 X509err(X509_F_X509_VERIFY_CERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); 212 ctx->error = X509_V_ERR_INVALID_CALL; 213 return -1; 214 } 215 216 cb = ctx->verify_cb; 217 218 /* 219 * first we make sure the chain we are going to build is present and that 220 * the first entry is in place 221 */ 222 if (((ctx->chain = sk_X509_new_null()) == NULL) || 223 (!sk_X509_push(ctx->chain, ctx->cert))) { 224 X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE); 225 ctx->error = X509_V_ERR_OUT_OF_MEM; 226 ok = -1; 227 goto err; 228 } 229 CRYPTO_add(&ctx->cert->references, 1, CRYPTO_LOCK_X509); 230 ctx->last_untrusted = 1; 231 232 /* We use a temporary STACK so we can chop and hack at it */ 233 if (ctx->untrusted != NULL 234 && (sktmp = sk_X509_dup(ctx->untrusted)) == NULL) { 235 X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE); 236 ctx->error = X509_V_ERR_OUT_OF_MEM; 237 ok = -1; 238 goto err; 239 } 240 241 num = sk_X509_num(ctx->chain); 242 x = sk_X509_value(ctx->chain, num - 1); 243 depth = param->depth; 244 245 for (;;) { 246 /* If we have enough, we break */ 247 if (depth < num) 248 break; /* FIXME: If this happens, we should take 249 * note of it and, if appropriate, use the 250 * X509_V_ERR_CERT_CHAIN_TOO_LONG error code 251 * later. */ 252 253 /* If we are self signed, we break */ 254 if (cert_self_signed(x)) 255 break; 256 /* 257 * If asked see if we can find issuer in trusted store first 258 */ 259 if (ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST) { 260 ok = ctx->get_issuer(&xtmp, ctx, x); 261 if (ok < 0) { 262 ctx->error = X509_V_ERR_STORE_LOOKUP; 263 goto err; 264 } 265 /* 266 * If successful for now free up cert so it will be picked up 267 * again later. 268 */ 269 if (ok > 0) { 270 X509_free(xtmp); 271 break; 272 } 273 } 274 275 /* If we were passed a cert chain, use it first */ 276 if (ctx->untrusted != NULL) { 277 xtmp = find_issuer(ctx, sktmp, x); 278 if (xtmp != NULL) { 279 if (!sk_X509_push(ctx->chain, xtmp)) { 280 X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE); 281 ctx->error = X509_V_ERR_OUT_OF_MEM; 282 ok = -1; 283 goto err; 284 } 285 CRYPTO_add(&xtmp->references, 1, CRYPTO_LOCK_X509); 286 (void)sk_X509_delete_ptr(sktmp, xtmp); 287 ctx->last_untrusted++; 288 x = xtmp; 289 num++; 290 /* 291 * reparse the full chain for the next one 292 */ 293 continue; 294 } 295 } 296 break; 297 } 298 299 /* Remember how many untrusted certs we have */ 300 j = num; 301 /* 302 * at this point, chain should contain a list of untrusted certificates. 303 * We now need to add at least one trusted one, if possible, otherwise we 304 * complain. 305 */ 306 307 do { 308 /* 309 * Examine last certificate in chain and see if it is self signed. 310 */ 311 i = sk_X509_num(ctx->chain); 312 x = sk_X509_value(ctx->chain, i - 1); 313 if (cert_self_signed(x)) { 314 /* we have a self signed certificate */ 315 if (sk_X509_num(ctx->chain) == 1) { 316 /* 317 * We have a single self signed certificate: see if we can 318 * find it in the store. We must have an exact match to avoid 319 * possible impersonation. 320 */ 321 ok = ctx->get_issuer(&xtmp, ctx, x); 322 if ((ok <= 0) || X509_cmp(x, xtmp)) { 323 ctx->error = X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT; 324 ctx->current_cert = x; 325 ctx->error_depth = i - 1; 326 if (ok == 1) 327 X509_free(xtmp); 328 bad_chain = 1; 329 ok = cb(0, ctx); 330 if (!ok) 331 goto err; 332 } else { 333 /* 334 * We have a match: replace certificate with store 335 * version so we get any trust settings. 336 */ 337 X509_free(x); 338 x = xtmp; 339 (void)sk_X509_set(ctx->chain, i - 1, x); 340 ctx->last_untrusted = 0; 341 } 342 } else { 343 /* 344 * extract and save self signed certificate for later use 345 */ 346 chain_ss = sk_X509_pop(ctx->chain); 347 ctx->last_untrusted--; 348 num--; 349 j--; 350 x = sk_X509_value(ctx->chain, num - 1); 351 } 352 } 353 /* We now lookup certs from the certificate store */ 354 for (;;) { 355 /* If we have enough, we break */ 356 if (depth < num) 357 break; 358 /* If we are self signed, we break */ 359 if (cert_self_signed(x)) 360 break; 361 ok = ctx->get_issuer(&xtmp, ctx, x); 362 363 if (ok < 0) { 364 ctx->error = X509_V_ERR_STORE_LOOKUP; 365 goto err; 366 } 367 if (ok == 0) 368 break; 369 x = xtmp; 370 if (!sk_X509_push(ctx->chain, x)) { 371 X509_free(xtmp); 372 X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE); 373 ctx->error = X509_V_ERR_OUT_OF_MEM; 374 ok = -1; 375 goto err; 376 } 377 num++; 378 } 379 380 /* we now have our chain, lets check it... */ 381 if ((trust = check_trust(ctx)) == X509_TRUST_REJECTED) { 382 /* Callback already issued */ 383 ok = 0; 384 goto err; 385 } 386 387 /* 388 * If it's not explicitly trusted then check if there is an alternative 389 * chain that could be used. We only do this if we haven't already 390 * checked via TRUSTED_FIRST and the user hasn't switched off alternate 391 * chain checking 392 */ 393 retry = 0; 394 if (trust != X509_TRUST_TRUSTED 395 && !(ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST) 396 && !(ctx->param->flags & X509_V_FLAG_NO_ALT_CHAINS)) { 397 while (j-- > 1) { 398 xtmp2 = sk_X509_value(ctx->chain, j - 1); 399 ok = ctx->get_issuer(&xtmp, ctx, xtmp2); 400 if (ok < 0) { 401 ctx->error = X509_V_ERR_STORE_LOOKUP; 402 goto err; 403 } 404 /* Check if we found an alternate chain */ 405 if (ok > 0) { 406 /* 407 * Free up the found cert we'll add it again later 408 */ 409 X509_free(xtmp); 410 411 /* 412 * Dump all the certs above this point - we've found an 413 * alternate chain 414 */ 415 while (num > j) { 416 xtmp = sk_X509_pop(ctx->chain); 417 X509_free(xtmp); 418 num--; 419 } 420 ctx->last_untrusted = sk_X509_num(ctx->chain); 421 retry = 1; 422 break; 423 } 424 } 425 } 426 } while (retry); 427 428 /* 429 * If not explicitly trusted then indicate error unless it's a single 430 * self signed certificate in which case we've indicated an error already 431 * and set bad_chain == 1 432 */ 433 if (trust != X509_TRUST_TRUSTED && !bad_chain) { 434 if ((chain_ss == NULL) || !ctx->check_issued(ctx, x, chain_ss)) { 435 if (ctx->last_untrusted >= num) 436 ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY; 437 else 438 ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT; 439 ctx->current_cert = x; 440 } else { 441 442 sk_X509_push(ctx->chain, chain_ss); 443 num++; 444 ctx->last_untrusted = num; 445 ctx->current_cert = chain_ss; 446 ctx->error = X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN; 447 chain_ss = NULL; 448 } 449 450 ctx->error_depth = num - 1; 451 bad_chain = 1; 452 ok = cb(0, ctx); 453 if (!ok) 454 goto err; 455 } 456 457 /* We have the chain complete: now we need to check its purpose */ 458 ok = check_chain_extensions(ctx); 459 460 if (!ok) 461 goto err; 462 463 /* Check name constraints */ 464 465 ok = check_name_constraints(ctx); 466 467 if (!ok) 468 goto err; 469 470 ok = check_id(ctx); 471 472 if (!ok) 473 goto err; 474 475 /* We may as well copy down any DSA parameters that are required */ 476 X509_get_pubkey_parameters(NULL, ctx->chain); 477 478 /* 479 * Check revocation status: we do this after copying parameters because 480 * they may be needed for CRL signature verification. 481 */ 482 483 ok = ctx->check_revocation(ctx); 484 if (!ok) 485 goto err; 486 487 err = X509_chain_check_suiteb(&ctx->error_depth, NULL, ctx->chain, 488 ctx->param->flags); 489 if (err != X509_V_OK) { 490 ctx->error = err; 491 ctx->current_cert = sk_X509_value(ctx->chain, ctx->error_depth); 492 ok = cb(0, ctx); 493 if (!ok) 494 goto err; 495 } 496 497 /* At this point, we have a chain and need to verify it */ 498 if (ctx->verify != NULL) 499 ok = ctx->verify(ctx); 500 else 501 ok = internal_verify(ctx); 502 if (!ok) 503 goto err; 504 505#ifndef OPENSSL_NO_RFC3779 506 /* RFC 3779 path validation, now that CRL check has been done */ 507 ok = v3_asid_validate_path(ctx); 508 if (!ok) 509 goto err; 510 ok = v3_addr_validate_path(ctx); 511 if (!ok) 512 goto err; 513#endif 514 515 /* If we get this far evaluate policies */ 516 if (!bad_chain && (ctx->param->flags & X509_V_FLAG_POLICY_CHECK)) 517 ok = ctx->check_policy(ctx); 518 if (!ok) 519 goto err; 520 if (0) { 521 err: 522 /* Ensure we return an error */ 523 if (ok > 0) 524 ok = 0; 525 X509_get_pubkey_parameters(NULL, ctx->chain); 526 } 527 if (sktmp != NULL) 528 sk_X509_free(sktmp); 529 if (chain_ss != NULL) 530 X509_free(chain_ss); 531 532 /* Safety net, error returns must set ctx->error */ 533 if (ok <= 0 && ctx->error == X509_V_OK) 534 ctx->error = X509_V_ERR_UNSPECIFIED; 535 return ok; 536} 537 538/* 539 * Given a STACK_OF(X509) find the issuer of cert (if any) 540 */ 541 542static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x) 543{ 544 int i; 545 X509 *issuer; 546 for (i = 0; i < sk_X509_num(sk); i++) { 547 issuer = sk_X509_value(sk, i); 548 if (ctx->check_issued(ctx, x, issuer)) 549 return issuer; 550 } 551 return NULL; 552} 553 554/* Given a possible certificate and issuer check them */ 555 556static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer) 557{ 558 int ret; 559 ret = X509_check_issued(issuer, x); 560 if (ret == X509_V_OK) 561 return 1; 562 /* If we haven't asked for issuer errors don't set ctx */ 563 if (!(ctx->param->flags & X509_V_FLAG_CB_ISSUER_CHECK)) 564 return 0; 565 566 ctx->error = ret; 567 ctx->current_cert = x; 568 ctx->current_issuer = issuer; 569 return ctx->verify_cb(0, ctx); 570} 571 572/* Alternative lookup method: look from a STACK stored in other_ctx */ 573 574static int get_issuer_sk(X509 **issuer, X509_STORE_CTX *ctx, X509 *x) 575{ 576 *issuer = find_issuer(ctx, ctx->other_ctx, x); 577 if (*issuer) { 578 CRYPTO_add(&(*issuer)->references, 1, CRYPTO_LOCK_X509); 579 return 1; 580 } else 581 return 0; 582} 583 584/* 585 * Check a certificate chains extensions for consistency with the supplied 586 * purpose 587 */ 588 589static int check_chain_extensions(X509_STORE_CTX *ctx) 590{ 591#ifdef OPENSSL_NO_CHAIN_VERIFY 592 return 1; 593#else 594 int i, ok = 0, must_be_ca, plen = 0; 595 X509 *x; 596 int (*cb) (int xok, X509_STORE_CTX *xctx); 597 int proxy_path_length = 0; 598 int purpose; 599 int allow_proxy_certs; 600 cb = ctx->verify_cb; 601 602 /*- 603 * must_be_ca can have 1 of 3 values: 604 * -1: we accept both CA and non-CA certificates, to allow direct 605 * use of self-signed certificates (which are marked as CA). 606 * 0: we only accept non-CA certificates. This is currently not 607 * used, but the possibility is present for future extensions. 608 * 1: we only accept CA certificates. This is currently used for 609 * all certificates in the chain except the leaf certificate. 610 */ 611 must_be_ca = -1; 612 613 /* CRL path validation */ 614 if (ctx->parent) { 615 allow_proxy_certs = 0; 616 purpose = X509_PURPOSE_CRL_SIGN; 617 } else { 618 allow_proxy_certs = 619 ! !(ctx->param->flags & X509_V_FLAG_ALLOW_PROXY_CERTS); 620 /* 621 * A hack to keep people who don't want to modify their software 622 * happy 623 */ 624 if (getenv("OPENSSL_ALLOW_PROXY_CERTS")) 625 allow_proxy_certs = 1; 626 purpose = ctx->param->purpose; 627 } 628 629 /* Check all untrusted certificates */ 630 for (i = 0; i < ctx->last_untrusted; i++) { 631 int ret; 632 x = sk_X509_value(ctx->chain, i); 633 if (!(ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL) 634 && (x->ex_flags & EXFLAG_CRITICAL)) { 635 ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION; 636 ctx->error_depth = i; 637 ctx->current_cert = x; 638 ok = cb(0, ctx); 639 if (!ok) 640 goto end; 641 } 642 if (!allow_proxy_certs && (x->ex_flags & EXFLAG_PROXY)) { 643 ctx->error = X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED; 644 ctx->error_depth = i; 645 ctx->current_cert = x; 646 ok = cb(0, ctx); 647 if (!ok) 648 goto end; 649 } 650 ret = X509_check_ca(x); 651 switch (must_be_ca) { 652 case -1: 653 if ((ctx->param->flags & X509_V_FLAG_X509_STRICT) 654 && (ret != 1) && (ret != 0)) { 655 ret = 0; 656 ctx->error = X509_V_ERR_INVALID_CA; 657 } else 658 ret = 1; 659 break; 660 case 0: 661 if (ret != 0) { 662 ret = 0; 663 ctx->error = X509_V_ERR_INVALID_NON_CA; 664 } else 665 ret = 1; 666 break; 667 default: 668 if ((ret == 0) 669 || ((ctx->param->flags & X509_V_FLAG_X509_STRICT) 670 && (ret != 1))) { 671 ret = 0; 672 ctx->error = X509_V_ERR_INVALID_CA; 673 } else 674 ret = 1; 675 break; 676 } 677 if (ret == 0) { 678 ctx->error_depth = i; 679 ctx->current_cert = x; 680 ok = cb(0, ctx); 681 if (!ok) 682 goto end; 683 } 684 if (ctx->param->purpose > 0) { 685 ret = X509_check_purpose(x, purpose, must_be_ca > 0); 686 if ((ret == 0) 687 || ((ctx->param->flags & X509_V_FLAG_X509_STRICT) 688 && (ret != 1))) { 689 ctx->error = X509_V_ERR_INVALID_PURPOSE; 690 ctx->error_depth = i; 691 ctx->current_cert = x; 692 ok = cb(0, ctx); 693 if (!ok) 694 goto end; 695 } 696 } 697 /* Check pathlen if not self issued */ 698 if ((i > 1) && !(x->ex_flags & EXFLAG_SI) 699 && (x->ex_pathlen != -1) 700 && (plen > (x->ex_pathlen + proxy_path_length + 1))) { 701 ctx->error = X509_V_ERR_PATH_LENGTH_EXCEEDED; 702 ctx->error_depth = i; 703 ctx->current_cert = x; 704 ok = cb(0, ctx); 705 if (!ok) 706 goto end; 707 } 708 /* Increment path length if not self issued */ 709 if (!(x->ex_flags & EXFLAG_SI)) 710 plen++; 711 /* 712 * If this certificate is a proxy certificate, the next certificate 713 * must be another proxy certificate or a EE certificate. If not, 714 * the next certificate must be a CA certificate. 715 */ 716 if (x->ex_flags & EXFLAG_PROXY) { 717 /* 718 * RFC3820, 4.1.3 (b)(1) stipulates that if pCPathLengthConstraint 719 * is less than max_path_length, the former should be copied to 720 * the latter, and 4.1.4 (a) stipulates that max_path_length 721 * should be verified to be larger than zero and decrement it. 722 * 723 * Because we're checking the certs in the reverse order, we start 724 * with verifying that proxy_path_length isn't larger than pcPLC, 725 * and copy the latter to the former if it is, and finally, 726 * increment proxy_path_length. 727 */ 728 if (x->ex_pcpathlen != -1) { 729 if (proxy_path_length > x->ex_pcpathlen) { 730 ctx->error = X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED; 731 ctx->error_depth = i; 732 ctx->current_cert = x; 733 ok = cb(0, ctx); 734 if (!ok) 735 goto end; 736 } 737 proxy_path_length = x->ex_pcpathlen; 738 } 739 proxy_path_length++; 740 must_be_ca = 0; 741 } else 742 must_be_ca = 1; 743 } 744 ok = 1; 745 end: 746 return ok; 747#endif 748} 749 750static int check_name_constraints(X509_STORE_CTX *ctx) 751{ 752 X509 *x; 753 int i, j, rv; 754 /* Check name constraints for all certificates */ 755 for (i = sk_X509_num(ctx->chain) - 1; i >= 0; i--) { 756 x = sk_X509_value(ctx->chain, i); 757 /* Ignore self issued certs unless last in chain */ 758 if (i && (x->ex_flags & EXFLAG_SI)) 759 continue; 760 761 /* 762 * Proxy certificates policy has an extra constraint, where the 763 * certificate subject MUST be the issuer with a single CN entry 764 * added. 765 * (RFC 3820: 3.4, 4.1.3 (a)(4)) 766 */ 767 if (x->ex_flags & EXFLAG_PROXY) { 768 X509_NAME *tmpsubject = X509_get_subject_name(x); 769 X509_NAME *tmpissuer = X509_get_issuer_name(x); 770 X509_NAME_ENTRY *tmpentry = NULL; 771 int last_object_nid = 0; 772 int err = X509_V_OK; 773 int last_object_loc = X509_NAME_entry_count(tmpsubject) - 1; 774 775 /* Check that there are at least two RDNs */ 776 if (last_object_loc < 1) { 777 err = X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION; 778 goto proxy_name_done; 779 } 780 781 /* 782 * Check that there is exactly one more RDN in subject as 783 * there is in issuer. 784 */ 785 if (X509_NAME_entry_count(tmpsubject) 786 != X509_NAME_entry_count(tmpissuer) + 1) { 787 err = X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION; 788 goto proxy_name_done; 789 } 790 791 /* 792 * Check that the last subject component isn't part of a 793 * multivalued RDN 794 */ 795 if (X509_NAME_get_entry(tmpsubject, last_object_loc)->set 796 == X509_NAME_get_entry(tmpsubject, last_object_loc - 1)->set) { 797 err = X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION; 798 goto proxy_name_done; 799 } 800 801 /* 802 * Check that the last subject RDN is a commonName, and that 803 * all the previous RDNs match the issuer exactly 804 */ 805 tmpsubject = X509_NAME_dup(tmpsubject); 806 if (tmpsubject == NULL) { 807 X509err(X509_F_CHECK_NAME_CONSTRAINTS, ERR_R_MALLOC_FAILURE); 808 ctx->error = X509_V_ERR_OUT_OF_MEM; 809 return 0; 810 } 811 812 tmpentry = 813 X509_NAME_delete_entry(tmpsubject, last_object_loc); 814 last_object_nid = 815 OBJ_obj2nid(X509_NAME_ENTRY_get_object(tmpentry)); 816 817 if (last_object_nid != NID_commonName 818 || X509_NAME_cmp(tmpsubject, tmpissuer) != 0) { 819 err = X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION; 820 } 821 822 X509_NAME_ENTRY_free(tmpentry); 823 X509_NAME_free(tmpsubject); 824 825 proxy_name_done: 826 if (err != X509_V_OK) { 827 ctx->error = err; 828 ctx->error_depth = i; 829 ctx->current_cert = x; 830 if (!ctx->verify_cb(0, ctx)) 831 return 0; 832 } 833 } 834 835 /* 836 * Check against constraints for all certificates higher in chain 837 * including trust anchor. Trust anchor not strictly speaking needed 838 * but if it includes constraints it is to be assumed it expects them 839 * to be obeyed. 840 */ 841 for (j = sk_X509_num(ctx->chain) - 1; j > i; j--) { 842 NAME_CONSTRAINTS *nc = sk_X509_value(ctx->chain, j)->nc; 843 if (nc) { 844 rv = NAME_CONSTRAINTS_check(x, nc); 845 switch (rv) { 846 case X509_V_OK: 847 continue; 848 case X509_V_ERR_OUT_OF_MEM: 849 ctx->error = rv; 850 return 0; 851 default: 852 ctx->error = rv; 853 ctx->error_depth = i; 854 ctx->current_cert = x; 855 if (!ctx->verify_cb(0, ctx)) 856 return 0; 857 break; 858 } 859 } 860 } 861 } 862 return 1; 863} 864 865static int check_id_error(X509_STORE_CTX *ctx, int errcode) 866{ 867 ctx->error = errcode; 868 ctx->current_cert = ctx->cert; 869 ctx->error_depth = 0; 870 return ctx->verify_cb(0, ctx); 871} 872 873static int check_hosts(X509 *x, X509_VERIFY_PARAM_ID *id) 874{ 875 int i; 876 int n = sk_OPENSSL_STRING_num(id->hosts); 877 char *name; 878 879 if (id->peername != NULL) { 880 OPENSSL_free(id->peername); 881 id->peername = NULL; 882 } 883 for (i = 0; i < n; ++i) { 884 name = sk_OPENSSL_STRING_value(id->hosts, i); 885 if (X509_check_host(x, name, 0, id->hostflags, &id->peername) > 0) 886 return 1; 887 } 888 return n == 0; 889} 890 891static int check_id(X509_STORE_CTX *ctx) 892{ 893 X509_VERIFY_PARAM *vpm = ctx->param; 894 X509_VERIFY_PARAM_ID *id = vpm->id; 895 X509 *x = ctx->cert; 896 if (id->hosts && check_hosts(x, id) <= 0) { 897 if (!check_id_error(ctx, X509_V_ERR_HOSTNAME_MISMATCH)) 898 return 0; 899 } 900 if (id->email && X509_check_email(x, id->email, id->emaillen, 0) <= 0) { 901 if (!check_id_error(ctx, X509_V_ERR_EMAIL_MISMATCH)) 902 return 0; 903 } 904 if (id->ip && X509_check_ip(x, id->ip, id->iplen, 0) <= 0) { 905 if (!check_id_error(ctx, X509_V_ERR_IP_ADDRESS_MISMATCH)) 906 return 0; 907 } 908 return 1; 909} 910 911static int check_trust(X509_STORE_CTX *ctx) 912{ 913 int i, ok; 914 X509 *x = NULL; 915 int (*cb) (int xok, X509_STORE_CTX *xctx); 916 cb = ctx->verify_cb; 917 /* Check all trusted certificates in chain */ 918 for (i = ctx->last_untrusted; i < sk_X509_num(ctx->chain); i++) { 919 x = sk_X509_value(ctx->chain, i); 920 ok = X509_check_trust(x, ctx->param->trust, 0); 921 /* If explicitly trusted return trusted */ 922 if (ok == X509_TRUST_TRUSTED) 923 return X509_TRUST_TRUSTED; 924 /* 925 * If explicitly rejected notify callback and reject if not 926 * overridden. 927 */ 928 if (ok == X509_TRUST_REJECTED) { 929 ctx->error_depth = i; 930 ctx->current_cert = x; 931 ctx->error = X509_V_ERR_CERT_REJECTED; 932 ok = cb(0, ctx); 933 if (!ok) 934 return X509_TRUST_REJECTED; 935 } 936 } 937 /* 938 * If we accept partial chains and have at least one trusted certificate 939 * return success. 940 */ 941 if (ctx->param->flags & X509_V_FLAG_PARTIAL_CHAIN) { 942 X509 *mx; 943 if (ctx->last_untrusted < sk_X509_num(ctx->chain)) 944 return X509_TRUST_TRUSTED; 945 x = sk_X509_value(ctx->chain, 0); 946 mx = lookup_cert_match(ctx, x); 947 if (mx) { 948 (void)sk_X509_set(ctx->chain, 0, mx); 949 X509_free(x); 950 ctx->last_untrusted = 0; 951 return X509_TRUST_TRUSTED; 952 } 953 } 954 955 /* 956 * If no trusted certs in chain at all return untrusted and allow 957 * standard (no issuer cert) etc errors to be indicated. 958 */ 959 return X509_TRUST_UNTRUSTED; 960} 961 962static int check_revocation(X509_STORE_CTX *ctx) 963{ 964 int i, last, ok; 965 if (!(ctx->param->flags & X509_V_FLAG_CRL_CHECK)) 966 return 1; 967 if (ctx->param->flags & X509_V_FLAG_CRL_CHECK_ALL) 968 last = sk_X509_num(ctx->chain) - 1; 969 else { 970 /* If checking CRL paths this isn't the EE certificate */ 971 if (ctx->parent) 972 return 1; 973 last = 0; 974 } 975 for (i = 0; i <= last; i++) { 976 ctx->error_depth = i; 977 ok = check_cert(ctx); 978 if (!ok) 979 return ok; 980 } 981 return 1; 982} 983 984static int check_cert(X509_STORE_CTX *ctx) 985{ 986 X509_CRL *crl = NULL, *dcrl = NULL; 987 X509 *x; 988 int ok, cnum; 989 unsigned int last_reasons; 990 cnum = ctx->error_depth; 991 x = sk_X509_value(ctx->chain, cnum); 992 ctx->current_cert = x; 993 ctx->current_issuer = NULL; 994 ctx->current_crl_score = 0; 995 ctx->current_reasons = 0; 996 if (x->ex_flags & EXFLAG_PROXY) 997 return 1; 998 while (ctx->current_reasons != CRLDP_ALL_REASONS) { 999 last_reasons = ctx->current_reasons; 1000 /* Try to retrieve relevant CRL */ 1001 if (ctx->get_crl) 1002 ok = ctx->get_crl(ctx, &crl, x); 1003 else 1004 ok = get_crl_delta(ctx, &crl, &dcrl, x); 1005 /* 1006 * If error looking up CRL, nothing we can do except notify callback 1007 */ 1008 if (!ok) { 1009 ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL; 1010 ok = ctx->verify_cb(0, ctx); 1011 goto err; 1012 } 1013 ctx->current_crl = crl; 1014 ok = ctx->check_crl(ctx, crl); 1015 if (!ok) 1016 goto err; 1017 1018 if (dcrl) { 1019 ok = ctx->check_crl(ctx, dcrl); 1020 if (!ok) 1021 goto err; 1022 ok = ctx->cert_crl(ctx, dcrl, x); 1023 if (!ok) 1024 goto err; 1025 } else 1026 ok = 1; 1027 1028 /* Don't look in full CRL if delta reason is removefromCRL */ 1029 if (ok != 2) { 1030 ok = ctx->cert_crl(ctx, crl, x); 1031 if (!ok) 1032 goto err; 1033 } 1034 1035 X509_CRL_free(crl); 1036 X509_CRL_free(dcrl); 1037 crl = NULL; 1038 dcrl = NULL; 1039 /* 1040 * If reasons not updated we wont get anywhere by another iteration, 1041 * so exit loop. 1042 */ 1043 if (last_reasons == ctx->current_reasons) { 1044 ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL; 1045 ok = ctx->verify_cb(0, ctx); 1046 goto err; 1047 } 1048 } 1049 err: 1050 X509_CRL_free(crl); 1051 X509_CRL_free(dcrl); 1052 1053 ctx->current_crl = NULL; 1054 return ok; 1055 1056} 1057 1058/* Check CRL times against values in X509_STORE_CTX */ 1059 1060static int check_crl_time(X509_STORE_CTX *ctx, X509_CRL *crl, int notify) 1061{ 1062 time_t *ptime; 1063 int i; 1064 if (notify) 1065 ctx->current_crl = crl; 1066 if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME) 1067 ptime = &ctx->param->check_time; 1068 else 1069 ptime = NULL; 1070 1071 i = X509_cmp_time(X509_CRL_get_lastUpdate(crl), ptime); 1072 if (i == 0) { 1073 if (!notify) 1074 return 0; 1075 ctx->error = X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD; 1076 if (!ctx->verify_cb(0, ctx)) 1077 return 0; 1078 } 1079 1080 if (i > 0) { 1081 if (!notify) 1082 return 0; 1083 ctx->error = X509_V_ERR_CRL_NOT_YET_VALID; 1084 if (!ctx->verify_cb(0, ctx)) 1085 return 0; 1086 } 1087 1088 if (X509_CRL_get_nextUpdate(crl)) { 1089 i = X509_cmp_time(X509_CRL_get_nextUpdate(crl), ptime); 1090 1091 if (i == 0) { 1092 if (!notify) 1093 return 0; 1094 ctx->error = X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD; 1095 if (!ctx->verify_cb(0, ctx)) 1096 return 0; 1097 } 1098 /* Ignore expiry of base CRL is delta is valid */ 1099 if ((i < 0) && !(ctx->current_crl_score & CRL_SCORE_TIME_DELTA)) { 1100 if (!notify) 1101 return 0; 1102 ctx->error = X509_V_ERR_CRL_HAS_EXPIRED; 1103 if (!ctx->verify_cb(0, ctx)) 1104 return 0; 1105 } 1106 } 1107 1108 if (notify) 1109 ctx->current_crl = NULL; 1110 1111 return 1; 1112} 1113 1114static int get_crl_sk(X509_STORE_CTX *ctx, X509_CRL **pcrl, X509_CRL **pdcrl, 1115 X509 **pissuer, int *pscore, unsigned int *preasons, 1116 STACK_OF(X509_CRL) *crls) 1117{ 1118 int i, crl_score, best_score = *pscore; 1119 unsigned int reasons, best_reasons = 0; 1120 X509 *x = ctx->current_cert; 1121 X509_CRL *crl, *best_crl = NULL; 1122 X509 *crl_issuer = NULL, *best_crl_issuer = NULL; 1123 1124 for (i = 0; i < sk_X509_CRL_num(crls); i++) { 1125 crl = sk_X509_CRL_value(crls, i); 1126 reasons = *preasons; 1127 crl_score = get_crl_score(ctx, &crl_issuer, &reasons, crl, x); 1128 if (crl_score < best_score || crl_score == 0) 1129 continue; 1130 /* If current CRL is equivalent use it if it is newer */ 1131 if (crl_score == best_score && best_crl != NULL) { 1132 int day, sec; 1133 if (ASN1_TIME_diff(&day, &sec, X509_CRL_get_lastUpdate(best_crl), 1134 X509_CRL_get_lastUpdate(crl)) == 0) 1135 continue; 1136 /* 1137 * ASN1_TIME_diff never returns inconsistent signs for |day| 1138 * and |sec|. 1139 */ 1140 if (day <= 0 && sec <= 0) 1141 continue; 1142 } 1143 best_crl = crl; 1144 best_crl_issuer = crl_issuer; 1145 best_score = crl_score; 1146 best_reasons = reasons; 1147 } 1148 1149 if (best_crl) { 1150 if (*pcrl) 1151 X509_CRL_free(*pcrl); 1152 *pcrl = best_crl; 1153 *pissuer = best_crl_issuer; 1154 *pscore = best_score; 1155 *preasons = best_reasons; 1156 CRYPTO_add(&best_crl->references, 1, CRYPTO_LOCK_X509_CRL); 1157 if (*pdcrl) { 1158 X509_CRL_free(*pdcrl); 1159 *pdcrl = NULL; 1160 } 1161 get_delta_sk(ctx, pdcrl, pscore, best_crl, crls); 1162 } 1163 1164 if (best_score >= CRL_SCORE_VALID) 1165 return 1; 1166 1167 return 0; 1168} 1169 1170/* 1171 * Compare two CRL extensions for delta checking purposes. They should be 1172 * both present or both absent. If both present all fields must be identical. 1173 */ 1174 1175static int crl_extension_match(X509_CRL *a, X509_CRL *b, int nid) 1176{ 1177 ASN1_OCTET_STRING *exta, *extb; 1178 int i; 1179 i = X509_CRL_get_ext_by_NID(a, nid, -1); 1180 if (i >= 0) { 1181 /* Can't have multiple occurrences */ 1182 if (X509_CRL_get_ext_by_NID(a, nid, i) != -1) 1183 return 0; 1184 exta = X509_EXTENSION_get_data(X509_CRL_get_ext(a, i)); 1185 } else 1186 exta = NULL; 1187 1188 i = X509_CRL_get_ext_by_NID(b, nid, -1); 1189 1190 if (i >= 0) { 1191 1192 if (X509_CRL_get_ext_by_NID(b, nid, i) != -1) 1193 return 0; 1194 extb = X509_EXTENSION_get_data(X509_CRL_get_ext(b, i)); 1195 } else 1196 extb = NULL; 1197 1198 if (!exta && !extb) 1199 return 1; 1200 1201 if (!exta || !extb) 1202 return 0; 1203 1204 if (ASN1_OCTET_STRING_cmp(exta, extb)) 1205 return 0; 1206 1207 return 1; 1208} 1209 1210/* See if a base and delta are compatible */ 1211 1212static int check_delta_base(X509_CRL *delta, X509_CRL *base) 1213{ 1214 /* Delta CRL must be a delta */ 1215 if (!delta->base_crl_number) 1216 return 0; 1217 /* Base must have a CRL number */ 1218 if (!base->crl_number) 1219 return 0; 1220 /* Issuer names must match */ 1221 if (X509_NAME_cmp(X509_CRL_get_issuer(base), X509_CRL_get_issuer(delta))) 1222 return 0; 1223 /* AKID and IDP must match */ 1224 if (!crl_extension_match(delta, base, NID_authority_key_identifier)) 1225 return 0; 1226 if (!crl_extension_match(delta, base, NID_issuing_distribution_point)) 1227 return 0; 1228 /* Delta CRL base number must not exceed Full CRL number. */ 1229 if (ASN1_INTEGER_cmp(delta->base_crl_number, base->crl_number) > 0) 1230 return 0; 1231 /* Delta CRL number must exceed full CRL number */ 1232 if (ASN1_INTEGER_cmp(delta->crl_number, base->crl_number) > 0) 1233 return 1; 1234 return 0; 1235} 1236 1237/* 1238 * For a given base CRL find a delta... maybe extend to delta scoring or 1239 * retrieve a chain of deltas... 1240 */ 1241 1242static void get_delta_sk(X509_STORE_CTX *ctx, X509_CRL **dcrl, int *pscore, 1243 X509_CRL *base, STACK_OF(X509_CRL) *crls) 1244{ 1245 X509_CRL *delta; 1246 int i; 1247 if (!(ctx->param->flags & X509_V_FLAG_USE_DELTAS)) 1248 return; 1249 if (!((ctx->current_cert->ex_flags | base->flags) & EXFLAG_FRESHEST)) 1250 return; 1251 for (i = 0; i < sk_X509_CRL_num(crls); i++) { 1252 delta = sk_X509_CRL_value(crls, i); 1253 if (check_delta_base(delta, base)) { 1254 if (check_crl_time(ctx, delta, 0)) 1255 *pscore |= CRL_SCORE_TIME_DELTA; 1256 CRYPTO_add(&delta->references, 1, CRYPTO_LOCK_X509_CRL); 1257 *dcrl = delta; 1258 return; 1259 } 1260 } 1261 *dcrl = NULL; 1262} 1263 1264/* 1265 * For a given CRL return how suitable it is for the supplied certificate 1266 * 'x'. The return value is a mask of several criteria. If the issuer is not 1267 * the certificate issuer this is returned in *pissuer. The reasons mask is 1268 * also used to determine if the CRL is suitable: if no new reasons the CRL 1269 * is rejected, otherwise reasons is updated. 1270 */ 1271 1272static int get_crl_score(X509_STORE_CTX *ctx, X509 **pissuer, 1273 unsigned int *preasons, X509_CRL *crl, X509 *x) 1274{ 1275 1276 int crl_score = 0; 1277 unsigned int tmp_reasons = *preasons, crl_reasons; 1278 1279 /* First see if we can reject CRL straight away */ 1280 1281 /* Invalid IDP cannot be processed */ 1282 if (crl->idp_flags & IDP_INVALID) 1283 return 0; 1284 /* Reason codes or indirect CRLs need extended CRL support */ 1285 if (!(ctx->param->flags & X509_V_FLAG_EXTENDED_CRL_SUPPORT)) { 1286 if (crl->idp_flags & (IDP_INDIRECT | IDP_REASONS)) 1287 return 0; 1288 } else if (crl->idp_flags & IDP_REASONS) { 1289 /* If no new reasons reject */ 1290 if (!(crl->idp_reasons & ~tmp_reasons)) 1291 return 0; 1292 } 1293 /* Don't process deltas at this stage */ 1294 else if (crl->base_crl_number) 1295 return 0; 1296 /* If issuer name doesn't match certificate need indirect CRL */ 1297 if (X509_NAME_cmp(X509_get_issuer_name(x), X509_CRL_get_issuer(crl))) { 1298 if (!(crl->idp_flags & IDP_INDIRECT)) 1299 return 0; 1300 } else 1301 crl_score |= CRL_SCORE_ISSUER_NAME; 1302 1303 if (!(crl->flags & EXFLAG_CRITICAL)) 1304 crl_score |= CRL_SCORE_NOCRITICAL; 1305 1306 /* Check expiry */ 1307 if (check_crl_time(ctx, crl, 0)) 1308 crl_score |= CRL_SCORE_TIME; 1309 1310 /* Check authority key ID and locate certificate issuer */ 1311 crl_akid_check(ctx, crl, pissuer, &crl_score); 1312 1313 /* If we can't locate certificate issuer at this point forget it */ 1314 1315 if (!(crl_score & CRL_SCORE_AKID)) 1316 return 0; 1317 1318 /* Check cert for matching CRL distribution points */ 1319 1320 if (crl_crldp_check(x, crl, crl_score, &crl_reasons)) { 1321 /* If no new reasons reject */ 1322 if (!(crl_reasons & ~tmp_reasons)) 1323 return 0; 1324 tmp_reasons |= crl_reasons; 1325 crl_score |= CRL_SCORE_SCOPE; 1326 } 1327 1328 *preasons = tmp_reasons; 1329 1330 return crl_score; 1331 1332} 1333 1334static void crl_akid_check(X509_STORE_CTX *ctx, X509_CRL *crl, 1335 X509 **pissuer, int *pcrl_score) 1336{ 1337 X509 *crl_issuer = NULL; 1338 X509_NAME *cnm = X509_CRL_get_issuer(crl); 1339 int cidx = ctx->error_depth; 1340 int i; 1341 1342 if (cidx != sk_X509_num(ctx->chain) - 1) 1343 cidx++; 1344 1345 crl_issuer = sk_X509_value(ctx->chain, cidx); 1346 1347 if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK) { 1348 if (*pcrl_score & CRL_SCORE_ISSUER_NAME) { 1349 *pcrl_score |= CRL_SCORE_AKID | CRL_SCORE_ISSUER_CERT; 1350 *pissuer = crl_issuer; 1351 return; 1352 } 1353 } 1354 1355 for (cidx++; cidx < sk_X509_num(ctx->chain); cidx++) { 1356 crl_issuer = sk_X509_value(ctx->chain, cidx); 1357 if (X509_NAME_cmp(X509_get_subject_name(crl_issuer), cnm)) 1358 continue; 1359 if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK) { 1360 *pcrl_score |= CRL_SCORE_AKID | CRL_SCORE_SAME_PATH; 1361 *pissuer = crl_issuer; 1362 return; 1363 } 1364 } 1365 1366 /* Anything else needs extended CRL support */ 1367 1368 if (!(ctx->param->flags & X509_V_FLAG_EXTENDED_CRL_SUPPORT)) 1369 return; 1370 1371 /* 1372 * Otherwise the CRL issuer is not on the path. Look for it in the set of 1373 * untrusted certificates. 1374 */ 1375 for (i = 0; i < sk_X509_num(ctx->untrusted); i++) { 1376 crl_issuer = sk_X509_value(ctx->untrusted, i); 1377 if (X509_NAME_cmp(X509_get_subject_name(crl_issuer), cnm)) 1378 continue; 1379 if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK) { 1380 *pissuer = crl_issuer; 1381 *pcrl_score |= CRL_SCORE_AKID; 1382 return; 1383 } 1384 } 1385} 1386 1387/* 1388 * Check the path of a CRL issuer certificate. This creates a new 1389 * X509_STORE_CTX and populates it with most of the parameters from the 1390 * parent. This could be optimised somewhat since a lot of path checking will 1391 * be duplicated by the parent, but this will rarely be used in practice. 1392 */ 1393 1394static int check_crl_path(X509_STORE_CTX *ctx, X509 *x) 1395{ 1396 X509_STORE_CTX crl_ctx; 1397 int ret; 1398 /* Don't allow recursive CRL path validation */ 1399 if (ctx->parent) 1400 return 0; 1401 if (!X509_STORE_CTX_init(&crl_ctx, ctx->ctx, x, ctx->untrusted)) 1402 return -1; 1403 1404 crl_ctx.crls = ctx->crls; 1405 /* Copy verify params across */ 1406 X509_STORE_CTX_set0_param(&crl_ctx, ctx->param); 1407 1408 crl_ctx.parent = ctx; 1409 crl_ctx.verify_cb = ctx->verify_cb; 1410 1411 /* Verify CRL issuer */ 1412 ret = X509_verify_cert(&crl_ctx); 1413 1414 if (ret <= 0) 1415 goto err; 1416 1417 /* Check chain is acceptable */ 1418 1419 ret = check_crl_chain(ctx, ctx->chain, crl_ctx.chain); 1420 err: 1421 X509_STORE_CTX_cleanup(&crl_ctx); 1422 return ret; 1423} 1424 1425/* 1426 * RFC3280 says nothing about the relationship between CRL path and 1427 * certificate path, which could lead to situations where a certificate could 1428 * be revoked or validated by a CA not authorised to do so. RFC5280 is more 1429 * strict and states that the two paths must end in the same trust anchor, 1430 * though some discussions remain... until this is resolved we use the 1431 * RFC5280 version 1432 */ 1433 1434static int check_crl_chain(X509_STORE_CTX *ctx, 1435 STACK_OF(X509) *cert_path, 1436 STACK_OF(X509) *crl_path) 1437{ 1438 X509 *cert_ta, *crl_ta; 1439 cert_ta = sk_X509_value(cert_path, sk_X509_num(cert_path) - 1); 1440 crl_ta = sk_X509_value(crl_path, sk_X509_num(crl_path) - 1); 1441 if (!X509_cmp(cert_ta, crl_ta)) 1442 return 1; 1443 return 0; 1444} 1445 1446/*- 1447 * Check for match between two dist point names: three separate cases. 1448 * 1. Both are relative names and compare X509_NAME types. 1449 * 2. One full, one relative. Compare X509_NAME to GENERAL_NAMES. 1450 * 3. Both are full names and compare two GENERAL_NAMES. 1451 * 4. One is NULL: automatic match. 1452 */ 1453 1454static int idp_check_dp(DIST_POINT_NAME *a, DIST_POINT_NAME *b) 1455{ 1456 X509_NAME *nm = NULL; 1457 GENERAL_NAMES *gens = NULL; 1458 GENERAL_NAME *gena, *genb; 1459 int i, j; 1460 if (!a || !b) 1461 return 1; 1462 if (a->type == 1) { 1463 if (!a->dpname) 1464 return 0; 1465 /* Case 1: two X509_NAME */ 1466 if (b->type == 1) { 1467 if (!b->dpname) 1468 return 0; 1469 if (!X509_NAME_cmp(a->dpname, b->dpname)) 1470 return 1; 1471 else 1472 return 0; 1473 } 1474 /* Case 2: set name and GENERAL_NAMES appropriately */ 1475 nm = a->dpname; 1476 gens = b->name.fullname; 1477 } else if (b->type == 1) { 1478 if (!b->dpname) 1479 return 0; 1480 /* Case 2: set name and GENERAL_NAMES appropriately */ 1481 gens = a->name.fullname; 1482 nm = b->dpname; 1483 } 1484 1485 /* Handle case 2 with one GENERAL_NAMES and one X509_NAME */ 1486 if (nm) { 1487 for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) { 1488 gena = sk_GENERAL_NAME_value(gens, i); 1489 if (gena->type != GEN_DIRNAME) 1490 continue; 1491 if (!X509_NAME_cmp(nm, gena->d.directoryName)) 1492 return 1; 1493 } 1494 return 0; 1495 } 1496 1497 /* Else case 3: two GENERAL_NAMES */ 1498 1499 for (i = 0; i < sk_GENERAL_NAME_num(a->name.fullname); i++) { 1500 gena = sk_GENERAL_NAME_value(a->name.fullname, i); 1501 for (j = 0; j < sk_GENERAL_NAME_num(b->name.fullname); j++) { 1502 genb = sk_GENERAL_NAME_value(b->name.fullname, j); 1503 if (!GENERAL_NAME_cmp(gena, genb)) 1504 return 1; 1505 } 1506 } 1507 1508 return 0; 1509 1510} 1511 1512static int crldp_check_crlissuer(DIST_POINT *dp, X509_CRL *crl, int crl_score) 1513{ 1514 int i; 1515 X509_NAME *nm = X509_CRL_get_issuer(crl); 1516 /* If no CRLissuer return is successful iff don't need a match */ 1517 if (!dp->CRLissuer) 1518 return ! !(crl_score & CRL_SCORE_ISSUER_NAME); 1519 for (i = 0; i < sk_GENERAL_NAME_num(dp->CRLissuer); i++) { 1520 GENERAL_NAME *gen = sk_GENERAL_NAME_value(dp->CRLissuer, i); 1521 if (gen->type != GEN_DIRNAME) 1522 continue; 1523 if (!X509_NAME_cmp(gen->d.directoryName, nm)) 1524 return 1; 1525 } 1526 return 0; 1527} 1528 1529/* Check CRLDP and IDP */ 1530 1531static int crl_crldp_check(X509 *x, X509_CRL *crl, int crl_score, 1532 unsigned int *preasons) 1533{ 1534 int i; 1535 if (crl->idp_flags & IDP_ONLYATTR) 1536 return 0; 1537 if (x->ex_flags & EXFLAG_CA) { 1538 if (crl->idp_flags & IDP_ONLYUSER) 1539 return 0; 1540 } else { 1541 if (crl->idp_flags & IDP_ONLYCA) 1542 return 0; 1543 } 1544 *preasons = crl->idp_reasons; 1545 for (i = 0; i < sk_DIST_POINT_num(x->crldp); i++) { 1546 DIST_POINT *dp = sk_DIST_POINT_value(x->crldp, i); 1547 if (crldp_check_crlissuer(dp, crl, crl_score)) { 1548 if (!crl->idp || idp_check_dp(dp->distpoint, crl->idp->distpoint)) { 1549 *preasons &= dp->dp_reasons; 1550 return 1; 1551 } 1552 } 1553 } 1554 if ((!crl->idp || !crl->idp->distpoint) 1555 && (crl_score & CRL_SCORE_ISSUER_NAME)) 1556 return 1; 1557 return 0; 1558} 1559 1560/* 1561 * Retrieve CRL corresponding to current certificate. If deltas enabled try 1562 * to find a delta CRL too 1563 */ 1564 1565static int get_crl_delta(X509_STORE_CTX *ctx, 1566 X509_CRL **pcrl, X509_CRL **pdcrl, X509 *x) 1567{ 1568 int ok; 1569 X509 *issuer = NULL; 1570 int crl_score = 0; 1571 unsigned int reasons; 1572 X509_CRL *crl = NULL, *dcrl = NULL; 1573 STACK_OF(X509_CRL) *skcrl; 1574 X509_NAME *nm = X509_get_issuer_name(x); 1575 reasons = ctx->current_reasons; 1576 ok = get_crl_sk(ctx, &crl, &dcrl, 1577 &issuer, &crl_score, &reasons, ctx->crls); 1578 1579 if (ok) 1580 goto done; 1581 1582 /* Lookup CRLs from store */ 1583 1584 skcrl = ctx->lookup_crls(ctx, nm); 1585 1586 /* If no CRLs found and a near match from get_crl_sk use that */ 1587 if (!skcrl && crl) 1588 goto done; 1589 1590 get_crl_sk(ctx, &crl, &dcrl, &issuer, &crl_score, &reasons, skcrl); 1591 1592 sk_X509_CRL_pop_free(skcrl, X509_CRL_free); 1593 1594 done: 1595 1596 /* If we got any kind of CRL use it and return success */ 1597 if (crl) { 1598 ctx->current_issuer = issuer; 1599 ctx->current_crl_score = crl_score; 1600 ctx->current_reasons = reasons; 1601 *pcrl = crl; 1602 *pdcrl = dcrl; 1603 return 1; 1604 } 1605 1606 return 0; 1607} 1608 1609/* Check CRL validity */ 1610static int check_crl(X509_STORE_CTX *ctx, X509_CRL *crl) 1611{ 1612 X509 *issuer = NULL; 1613 EVP_PKEY *ikey = NULL; 1614 int ok = 0, chnum, cnum; 1615 cnum = ctx->error_depth; 1616 chnum = sk_X509_num(ctx->chain) - 1; 1617 /* if we have an alternative CRL issuer cert use that */ 1618 if (ctx->current_issuer) 1619 issuer = ctx->current_issuer; 1620 1621 /* 1622 * Else find CRL issuer: if not last certificate then issuer is next 1623 * certificate in chain. 1624 */ 1625 else if (cnum < chnum) 1626 issuer = sk_X509_value(ctx->chain, cnum + 1); 1627 else { 1628 issuer = sk_X509_value(ctx->chain, chnum); 1629 /* If not self signed, can't check signature */ 1630 if (!ctx->check_issued(ctx, issuer, issuer)) { 1631 ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER; 1632 ok = ctx->verify_cb(0, ctx); 1633 if (!ok) 1634 goto err; 1635 } 1636 } 1637 1638 if (issuer) { 1639 /* 1640 * Skip most tests for deltas because they have already been done 1641 */ 1642 if (!crl->base_crl_number) { 1643 /* Check for cRLSign bit if keyUsage present */ 1644 if ((issuer->ex_flags & EXFLAG_KUSAGE) && 1645 !(issuer->ex_kusage & KU_CRL_SIGN)) { 1646 ctx->error = X509_V_ERR_KEYUSAGE_NO_CRL_SIGN; 1647 ok = ctx->verify_cb(0, ctx); 1648 if (!ok) 1649 goto err; 1650 } 1651 1652 if (!(ctx->current_crl_score & CRL_SCORE_SCOPE)) { 1653 ctx->error = X509_V_ERR_DIFFERENT_CRL_SCOPE; 1654 ok = ctx->verify_cb(0, ctx); 1655 if (!ok) 1656 goto err; 1657 } 1658 1659 if (!(ctx->current_crl_score & CRL_SCORE_SAME_PATH)) { 1660 if (check_crl_path(ctx, ctx->current_issuer) <= 0) { 1661 ctx->error = X509_V_ERR_CRL_PATH_VALIDATION_ERROR; 1662 ok = ctx->verify_cb(0, ctx); 1663 if (!ok) 1664 goto err; 1665 } 1666 } 1667 1668 if (crl->idp_flags & IDP_INVALID) { 1669 ctx->error = X509_V_ERR_INVALID_EXTENSION; 1670 ok = ctx->verify_cb(0, ctx); 1671 if (!ok) 1672 goto err; 1673 } 1674 1675 } 1676 1677 if (!(ctx->current_crl_score & CRL_SCORE_TIME)) { 1678 ok = check_crl_time(ctx, crl, 1); 1679 if (!ok) 1680 goto err; 1681 } 1682 1683 /* Attempt to get issuer certificate public key */ 1684 ikey = X509_get_pubkey(issuer); 1685 1686 if (!ikey) { 1687 ctx->error = X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY; 1688 ok = ctx->verify_cb(0, ctx); 1689 if (!ok) 1690 goto err; 1691 } else { 1692 int rv; 1693 rv = X509_CRL_check_suiteb(crl, ikey, ctx->param->flags); 1694 if (rv != X509_V_OK) { 1695 ctx->error = rv; 1696 ok = ctx->verify_cb(0, ctx); 1697 if (!ok) 1698 goto err; 1699 } 1700 /* Verify CRL signature */ 1701 if (X509_CRL_verify(crl, ikey) <= 0) { 1702 ctx->error = X509_V_ERR_CRL_SIGNATURE_FAILURE; 1703 ok = ctx->verify_cb(0, ctx); 1704 if (!ok) 1705 goto err; 1706 } 1707 } 1708 } 1709 1710 ok = 1; 1711 1712 err: 1713 EVP_PKEY_free(ikey); 1714 return ok; 1715} 1716 1717/* Check certificate against CRL */ 1718static int cert_crl(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x) 1719{ 1720 int ok; 1721 X509_REVOKED *rev; 1722 /* 1723 * The rules changed for this... previously if a CRL contained unhandled 1724 * critical extensions it could still be used to indicate a certificate 1725 * was revoked. This has since been changed since critical extension can 1726 * change the meaning of CRL entries. 1727 */ 1728 if (!(ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL) 1729 && (crl->flags & EXFLAG_CRITICAL)) { 1730 ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION; 1731 ok = ctx->verify_cb(0, ctx); 1732 if (!ok) 1733 return 0; 1734 } 1735 /* 1736 * Look for serial number of certificate in CRL If found make sure reason 1737 * is not removeFromCRL. 1738 */ 1739 if (X509_CRL_get0_by_cert(crl, &rev, x)) { 1740 if (rev->reason == CRL_REASON_REMOVE_FROM_CRL) 1741 return 2; 1742 ctx->error = X509_V_ERR_CERT_REVOKED; 1743 ok = ctx->verify_cb(0, ctx); 1744 if (!ok) 1745 return 0; 1746 } 1747 1748 return 1; 1749} 1750 1751static int check_policy(X509_STORE_CTX *ctx) 1752{ 1753 int ret; 1754 if (ctx->parent) 1755 return 1; 1756 ret = X509_policy_check(&ctx->tree, &ctx->explicit_policy, ctx->chain, 1757 ctx->param->policies, ctx->param->flags); 1758 if (ret == 0) { 1759 X509err(X509_F_CHECK_POLICY, ERR_R_MALLOC_FAILURE); 1760 ctx->error = X509_V_ERR_OUT_OF_MEM; 1761 return 0; 1762 } 1763 /* Invalid or inconsistent extensions */ 1764 if (ret == -1) { 1765 /* 1766 * Locate certificates with bad extensions and notify callback. 1767 */ 1768 X509 *x; 1769 int i; 1770 for (i = 1; i < sk_X509_num(ctx->chain); i++) { 1771 x = sk_X509_value(ctx->chain, i); 1772 if (!(x->ex_flags & EXFLAG_INVALID_POLICY)) 1773 continue; 1774 ctx->current_cert = x; 1775 ctx->error = X509_V_ERR_INVALID_POLICY_EXTENSION; 1776 if (!ctx->verify_cb(0, ctx)) 1777 return 0; 1778 } 1779 return 1; 1780 } 1781 if (ret == -2) { 1782 ctx->current_cert = NULL; 1783 ctx->error = X509_V_ERR_NO_EXPLICIT_POLICY; 1784 return ctx->verify_cb(0, ctx); 1785 } 1786 1787 if (ctx->param->flags & X509_V_FLAG_NOTIFY_POLICY) { 1788 ctx->current_cert = NULL; 1789 /* 1790 * Verification errors need to be "sticky", a callback may have allowed 1791 * an SSL handshake to continue despite an error, and we must then 1792 * remain in an error state. Therefore, we MUST NOT clear earlier 1793 * verification errors by setting the error to X509_V_OK. 1794 */ 1795 if (!ctx->verify_cb(2, ctx)) 1796 return 0; 1797 } 1798 1799 return 1; 1800} 1801 1802static int check_cert_time(X509_STORE_CTX *ctx, X509 *x) 1803{ 1804 time_t *ptime; 1805 int i; 1806 1807 if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME) 1808 ptime = &ctx->param->check_time; 1809 else 1810 ptime = NULL; 1811 1812 i = X509_cmp_time(X509_get_notBefore(x), ptime); 1813 if (i == 0) { 1814 ctx->error = X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD; 1815 ctx->current_cert = x; 1816 if (!ctx->verify_cb(0, ctx)) 1817 return 0; 1818 } 1819 1820 if (i > 0) { 1821 ctx->error = X509_V_ERR_CERT_NOT_YET_VALID; 1822 ctx->current_cert = x; 1823 if (!ctx->verify_cb(0, ctx)) 1824 return 0; 1825 } 1826 1827 i = X509_cmp_time(X509_get_notAfter(x), ptime); 1828 if (i == 0) { 1829 ctx->error = X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD; 1830 ctx->current_cert = x; 1831 if (!ctx->verify_cb(0, ctx)) 1832 return 0; 1833 } 1834 1835 if (i < 0) { 1836 ctx->error = X509_V_ERR_CERT_HAS_EXPIRED; 1837 ctx->current_cert = x; 1838 if (!ctx->verify_cb(0, ctx)) 1839 return 0; 1840 } 1841 1842 return 1; 1843} 1844 1845static int internal_verify(X509_STORE_CTX *ctx) 1846{ 1847 int ok = 0, n; 1848 X509 *xs, *xi; 1849 EVP_PKEY *pkey = NULL; 1850 int (*cb) (int xok, X509_STORE_CTX *xctx); 1851 1852 cb = ctx->verify_cb; 1853 1854 n = sk_X509_num(ctx->chain); 1855 ctx->error_depth = n - 1; 1856 n--; 1857 xi = sk_X509_value(ctx->chain, n); 1858 1859 if (ctx->check_issued(ctx, xi, xi)) 1860 xs = xi; 1861 else { 1862 if (ctx->param->flags & X509_V_FLAG_PARTIAL_CHAIN) { 1863 xs = xi; 1864 goto check_cert; 1865 } 1866 if (n <= 0) { 1867 ctx->error = X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE; 1868 ctx->current_cert = xi; 1869 ok = cb(0, ctx); 1870 goto end; 1871 } else { 1872 n--; 1873 ctx->error_depth = n; 1874 xs = sk_X509_value(ctx->chain, n); 1875 } 1876 } 1877 1878/* ctx->error=0; not needed */ 1879 while (n >= 0) { 1880 ctx->error_depth = n; 1881 1882 /* 1883 * Skip signature check for self signed certificates unless 1884 * explicitly asked for. It doesn't add any security and just wastes 1885 * time. 1886 */ 1887 if (!xs->valid 1888 && (xs != xi 1889 || (ctx->param->flags & X509_V_FLAG_CHECK_SS_SIGNATURE))) { 1890 if ((pkey = X509_get_pubkey(xi)) == NULL) { 1891 ctx->error = X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY; 1892 ctx->current_cert = xi; 1893 ok = (*cb) (0, ctx); 1894 if (!ok) 1895 goto end; 1896 } else if (X509_verify(xs, pkey) <= 0) { 1897 ctx->error = X509_V_ERR_CERT_SIGNATURE_FAILURE; 1898 ctx->current_cert = xs; 1899 ok = (*cb) (0, ctx); 1900 if (!ok) { 1901 EVP_PKEY_free(pkey); 1902 goto end; 1903 } 1904 } 1905 EVP_PKEY_free(pkey); 1906 pkey = NULL; 1907 } 1908 1909 xs->valid = 1; 1910 1911 check_cert: 1912 ok = check_cert_time(ctx, xs); 1913 if (!ok) 1914 goto end; 1915 1916 /* The last error (if any) is still in the error value */ 1917 ctx->current_issuer = xi; 1918 ctx->current_cert = xs; 1919 ok = (*cb) (1, ctx); 1920 if (!ok) 1921 goto end; 1922 1923 n--; 1924 if (n >= 0) { 1925 xi = xs; 1926 xs = sk_X509_value(ctx->chain, n); 1927 } 1928 } 1929 ok = 1; 1930 end: 1931 return ok; 1932} 1933 1934int X509_cmp_current_time(const ASN1_TIME *ctm) 1935{ 1936 return X509_cmp_time(ctm, NULL); 1937} 1938 1939int X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time) 1940{ 1941 static const size_t utctime_length = sizeof("YYMMDDHHMMSSZ") - 1; 1942 static const size_t generalizedtime_length = sizeof("YYYYMMDDHHMMSSZ") - 1; 1943 ASN1_TIME *asn1_cmp_time = NULL; 1944 int i, day, sec, ret = 0; 1945 1946 /* 1947 * Note that ASN.1 allows much more slack in the time format than RFC5280. 1948 * In RFC5280, the representation is fixed: 1949 * UTCTime: YYMMDDHHMMSSZ 1950 * GeneralizedTime: YYYYMMDDHHMMSSZ 1951 * 1952 * We do NOT currently enforce the following RFC 5280 requirement: 1953 * "CAs conforming to this profile MUST always encode certificate 1954 * validity dates through the year 2049 as UTCTime; certificate validity 1955 * dates in 2050 or later MUST be encoded as GeneralizedTime." 1956 */ 1957 switch (ctm->type) { 1958 case V_ASN1_UTCTIME: 1959 if (ctm->length != (int)(utctime_length)) 1960 return 0; 1961 break; 1962 case V_ASN1_GENERALIZEDTIME: 1963 if (ctm->length != (int)(generalizedtime_length)) 1964 return 0; 1965 break; 1966 default: 1967 return 0; 1968 } 1969 1970 /** 1971 * Verify the format: the ASN.1 functions we use below allow a more 1972 * flexible format than what's mandated by RFC 5280. 1973 * Digit and date ranges will be verified in the conversion methods. 1974 */ 1975 for (i = 0; i < ctm->length - 1; i++) { 1976 if (!isdigit(ctm->data[i])) 1977 return 0; 1978 } 1979 if (ctm->data[ctm->length - 1] != 'Z') 1980 return 0; 1981 1982 /* 1983 * There is ASN1_UTCTIME_cmp_time_t but no 1984 * ASN1_GENERALIZEDTIME_cmp_time_t or ASN1_TIME_cmp_time_t, 1985 * so we go through ASN.1 1986 */ 1987 asn1_cmp_time = X509_time_adj(NULL, 0, cmp_time); 1988 if (asn1_cmp_time == NULL) 1989 goto err; 1990 if (!ASN1_TIME_diff(&day, &sec, ctm, asn1_cmp_time)) 1991 goto err; 1992 1993 /* 1994 * X509_cmp_time comparison is <=. 1995 * The return value 0 is reserved for errors. 1996 */ 1997 ret = (day >= 0 && sec >= 0) ? -1 : 1; 1998 1999 err: 2000 ASN1_TIME_free(asn1_cmp_time); 2001 return ret; 2002} 2003 2004ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj) 2005{ 2006 return X509_time_adj(s, adj, NULL); 2007} 2008 2009ASN1_TIME *X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_tm) 2010{ 2011 return X509_time_adj_ex(s, 0, offset_sec, in_tm); 2012} 2013 2014ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s, 2015 int offset_day, long offset_sec, time_t *in_tm) 2016{ 2017 time_t t; 2018 2019 if (in_tm) 2020 t = *in_tm; 2021 else 2022 time(&t); 2023 2024 if (s && !(s->flags & ASN1_STRING_FLAG_MSTRING)) { 2025 if (s->type == V_ASN1_UTCTIME) 2026 return ASN1_UTCTIME_adj(s, t, offset_day, offset_sec); 2027 if (s->type == V_ASN1_GENERALIZEDTIME) 2028 return ASN1_GENERALIZEDTIME_adj(s, t, offset_day, offset_sec); 2029 } 2030 return ASN1_TIME_adj(s, t, offset_day, offset_sec); 2031} 2032 2033int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain) 2034{ 2035 EVP_PKEY *ktmp = NULL, *ktmp2; 2036 int i, j; 2037 2038 if ((pkey != NULL) && !EVP_PKEY_missing_parameters(pkey)) 2039 return 1; 2040 2041 for (i = 0; i < sk_X509_num(chain); i++) { 2042 ktmp = X509_get_pubkey(sk_X509_value(chain, i)); 2043 if (ktmp == NULL) { 2044 X509err(X509_F_X509_GET_PUBKEY_PARAMETERS, 2045 X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY); 2046 return 0; 2047 } 2048 if (!EVP_PKEY_missing_parameters(ktmp)) 2049 break; 2050 else { 2051 EVP_PKEY_free(ktmp); 2052 ktmp = NULL; 2053 } 2054 } 2055 if (ktmp == NULL) { 2056 X509err(X509_F_X509_GET_PUBKEY_PARAMETERS, 2057 X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN); 2058 return 0; 2059 } 2060 2061 /* first, populate the other certs */ 2062 for (j = i - 1; j >= 0; j--) { 2063 ktmp2 = X509_get_pubkey(sk_X509_value(chain, j)); 2064 EVP_PKEY_copy_parameters(ktmp2, ktmp); 2065 EVP_PKEY_free(ktmp2); 2066 } 2067 2068 if (pkey != NULL) 2069 EVP_PKEY_copy_parameters(pkey, ktmp); 2070 EVP_PKEY_free(ktmp); 2071 return 1; 2072} 2073 2074/* Make a delta CRL as the diff between two full CRLs */ 2075 2076X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer, 2077 EVP_PKEY *skey, const EVP_MD *md, unsigned int flags) 2078{ 2079 X509_CRL *crl = NULL; 2080 int i; 2081 STACK_OF(X509_REVOKED) *revs = NULL; 2082 /* CRLs can't be delta already */ 2083 if (base->base_crl_number || newer->base_crl_number) { 2084 X509err(X509_F_X509_CRL_DIFF, X509_R_CRL_ALREADY_DELTA); 2085 return NULL; 2086 } 2087 /* Base and new CRL must have a CRL number */ 2088 if (!base->crl_number || !newer->crl_number) { 2089 X509err(X509_F_X509_CRL_DIFF, X509_R_NO_CRL_NUMBER); 2090 return NULL; 2091 } 2092 /* Issuer names must match */ 2093 if (X509_NAME_cmp(X509_CRL_get_issuer(base), X509_CRL_get_issuer(newer))) { 2094 X509err(X509_F_X509_CRL_DIFF, X509_R_ISSUER_MISMATCH); 2095 return NULL; 2096 } 2097 /* AKID and IDP must match */ 2098 if (!crl_extension_match(base, newer, NID_authority_key_identifier)) { 2099 X509err(X509_F_X509_CRL_DIFF, X509_R_AKID_MISMATCH); 2100 return NULL; 2101 } 2102 if (!crl_extension_match(base, newer, NID_issuing_distribution_point)) { 2103 X509err(X509_F_X509_CRL_DIFF, X509_R_IDP_MISMATCH); 2104 return NULL; 2105 } 2106 /* Newer CRL number must exceed full CRL number */ 2107 if (ASN1_INTEGER_cmp(newer->crl_number, base->crl_number) <= 0) { 2108 X509err(X509_F_X509_CRL_DIFF, X509_R_NEWER_CRL_NOT_NEWER); 2109 return NULL; 2110 } 2111 /* CRLs must verify */ 2112 if (skey && (X509_CRL_verify(base, skey) <= 0 || 2113 X509_CRL_verify(newer, skey) <= 0)) { 2114 X509err(X509_F_X509_CRL_DIFF, X509_R_CRL_VERIFY_FAILURE); 2115 return NULL; 2116 } 2117 /* Create new CRL */ 2118 crl = X509_CRL_new(); 2119 if (!crl || !X509_CRL_set_version(crl, 1)) 2120 goto memerr; 2121 /* Set issuer name */ 2122 if (!X509_CRL_set_issuer_name(crl, X509_CRL_get_issuer(newer))) 2123 goto memerr; 2124 2125 if (!X509_CRL_set_lastUpdate(crl, X509_CRL_get_lastUpdate(newer))) 2126 goto memerr; 2127 if (!X509_CRL_set_nextUpdate(crl, X509_CRL_get_nextUpdate(newer))) 2128 goto memerr; 2129 2130 /* Set base CRL number: must be critical */ 2131 2132 if (!X509_CRL_add1_ext_i2d(crl, NID_delta_crl, base->crl_number, 1, 0)) 2133 goto memerr; 2134 2135 /* 2136 * Copy extensions across from newest CRL to delta: this will set CRL 2137 * number to correct value too. 2138 */ 2139 2140 for (i = 0; i < X509_CRL_get_ext_count(newer); i++) { 2141 X509_EXTENSION *ext; 2142 ext = X509_CRL_get_ext(newer, i); 2143 if (!X509_CRL_add_ext(crl, ext, -1)) 2144 goto memerr; 2145 } 2146 2147 /* Go through revoked entries, copying as needed */ 2148 2149 revs = X509_CRL_get_REVOKED(newer); 2150 2151 for (i = 0; i < sk_X509_REVOKED_num(revs); i++) { 2152 X509_REVOKED *rvn, *rvtmp; 2153 rvn = sk_X509_REVOKED_value(revs, i); 2154 /* 2155 * Add only if not also in base. TODO: need something cleverer here 2156 * for some more complex CRLs covering multiple CAs. 2157 */ 2158 if (!X509_CRL_get0_by_serial(base, &rvtmp, rvn->serialNumber)) { 2159 rvtmp = X509_REVOKED_dup(rvn); 2160 if (!rvtmp) 2161 goto memerr; 2162 if (!X509_CRL_add0_revoked(crl, rvtmp)) { 2163 X509_REVOKED_free(rvtmp); 2164 goto memerr; 2165 } 2166 } 2167 } 2168 /* TODO: optionally prune deleted entries */ 2169 2170 if (skey && md && !X509_CRL_sign(crl, skey, md)) 2171 goto memerr; 2172 2173 return crl; 2174 2175 memerr: 2176 X509err(X509_F_X509_CRL_DIFF, ERR_R_MALLOC_FAILURE); 2177 if (crl) 2178 X509_CRL_free(crl); 2179 return NULL; 2180} 2181 2182int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, 2183 CRYPTO_EX_new *new_func, 2184 CRYPTO_EX_dup *dup_func, 2185 CRYPTO_EX_free *free_func) 2186{ 2187 /* 2188 * This function is (usually) called only once, by 2189 * SSL_get_ex_data_X509_STORE_CTX_idx (ssl/ssl_cert.c). 2190 */ 2191 return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, argl, argp, 2192 new_func, dup_func, free_func); 2193} 2194 2195int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data) 2196{ 2197 return CRYPTO_set_ex_data(&ctx->ex_data, idx, data); 2198} 2199 2200void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx) 2201{ 2202 return CRYPTO_get_ex_data(&ctx->ex_data, idx); 2203} 2204 2205int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx) 2206{ 2207 return ctx->error; 2208} 2209 2210void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err) 2211{ 2212 ctx->error = err; 2213} 2214 2215int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx) 2216{ 2217 return ctx->error_depth; 2218} 2219 2220X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx) 2221{ 2222 return ctx->current_cert; 2223} 2224 2225STACK_OF(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx) 2226{ 2227 return ctx->chain; 2228} 2229 2230STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx) 2231{ 2232 if (!ctx->chain) 2233 return NULL; 2234 return X509_chain_up_ref(ctx->chain); 2235} 2236 2237X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx) 2238{ 2239 return ctx->current_issuer; 2240} 2241 2242X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx) 2243{ 2244 return ctx->current_crl; 2245} 2246 2247X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx) 2248{ 2249 return ctx->parent; 2250} 2251 2252void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x) 2253{ 2254 ctx->cert = x; 2255} 2256 2257void X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk) 2258{ 2259 ctx->untrusted = sk; 2260} 2261 2262void X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk) 2263{ 2264 ctx->crls = sk; 2265} 2266 2267int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose) 2268{ 2269 return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0); 2270} 2271 2272int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust) 2273{ 2274 return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust); 2275} 2276 2277/* 2278 * This function is used to set the X509_STORE_CTX purpose and trust values. 2279 * This is intended to be used when another structure has its own trust and 2280 * purpose values which (if set) will be inherited by the ctx. If they aren't 2281 * set then we will usually have a default purpose in mind which should then 2282 * be used to set the trust value. An example of this is SSL use: an SSL 2283 * structure will have its own purpose and trust settings which the 2284 * application can set: if they aren't set then we use the default of SSL 2285 * client/server. 2286 */ 2287 2288int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose, 2289 int purpose, int trust) 2290{ 2291 int idx; 2292 /* If purpose not set use default */ 2293 if (!purpose) 2294 purpose = def_purpose; 2295 /* If we have a purpose then check it is valid */ 2296 if (purpose) { 2297 X509_PURPOSE *ptmp; 2298 idx = X509_PURPOSE_get_by_id(purpose); 2299 if (idx == -1) { 2300 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT, 2301 X509_R_UNKNOWN_PURPOSE_ID); 2302 return 0; 2303 } 2304 ptmp = X509_PURPOSE_get0(idx); 2305 if (ptmp->trust == X509_TRUST_DEFAULT) { 2306 idx = X509_PURPOSE_get_by_id(def_purpose); 2307 if (idx == -1) { 2308 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT, 2309 X509_R_UNKNOWN_PURPOSE_ID); 2310 return 0; 2311 } 2312 ptmp = X509_PURPOSE_get0(idx); 2313 } 2314 /* If trust not set then get from purpose default */ 2315 if (!trust) 2316 trust = ptmp->trust; 2317 } 2318 if (trust) { 2319 idx = X509_TRUST_get_by_id(trust); 2320 if (idx == -1) { 2321 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT, 2322 X509_R_UNKNOWN_TRUST_ID); 2323 return 0; 2324 } 2325 } 2326 2327 if (purpose && !ctx->param->purpose) 2328 ctx->param->purpose = purpose; 2329 if (trust && !ctx->param->trust) 2330 ctx->param->trust = trust; 2331 return 1; 2332} 2333 2334X509_STORE_CTX *X509_STORE_CTX_new(void) 2335{ 2336 X509_STORE_CTX *ctx; 2337 ctx = (X509_STORE_CTX *)OPENSSL_malloc(sizeof(X509_STORE_CTX)); 2338 if (!ctx) { 2339 X509err(X509_F_X509_STORE_CTX_NEW, ERR_R_MALLOC_FAILURE); 2340 return NULL; 2341 } 2342 memset(ctx, 0, sizeof(X509_STORE_CTX)); 2343 return ctx; 2344} 2345 2346void X509_STORE_CTX_free(X509_STORE_CTX *ctx) 2347{ 2348 if (!ctx) 2349 return; 2350 X509_STORE_CTX_cleanup(ctx); 2351 OPENSSL_free(ctx); 2352} 2353 2354int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, 2355 STACK_OF(X509) *chain) 2356{ 2357 int ret = 1; 2358 ctx->ctx = store; 2359 ctx->current_method = 0; 2360 ctx->cert = x509; 2361 ctx->untrusted = chain; 2362 ctx->crls = NULL; 2363 ctx->last_untrusted = 0; 2364 ctx->other_ctx = NULL; 2365 ctx->valid = 0; 2366 ctx->chain = NULL; 2367 ctx->error = 0; 2368 ctx->explicit_policy = 0; 2369 ctx->error_depth = 0; 2370 ctx->current_cert = NULL; 2371 ctx->current_issuer = NULL; 2372 ctx->current_crl = NULL; 2373 ctx->current_crl_score = 0; 2374 ctx->current_reasons = 0; 2375 ctx->tree = NULL; 2376 ctx->parent = NULL; 2377 /* Zero ex_data to make sure we're cleanup-safe */ 2378 memset(&ctx->ex_data, 0, sizeof(ctx->ex_data)); 2379 2380 ctx->param = X509_VERIFY_PARAM_new(); 2381 if (!ctx->param) { 2382 X509err(X509_F_X509_STORE_CTX_INIT, ERR_R_MALLOC_FAILURE); 2383 return 0; 2384 } 2385 2386 /* 2387 * Inherit callbacks and flags from X509_STORE if not set use defaults. 2388 */ 2389 if (store) 2390 ret = X509_VERIFY_PARAM_inherit(ctx->param, store->param); 2391 else 2392 ctx->param->inh_flags |= X509_VP_FLAG_DEFAULT | X509_VP_FLAG_ONCE; 2393 2394 if (store) { 2395 ctx->verify_cb = store->verify_cb; 2396 /* Seems to always be 0 in OpenSSL, else must be idempotent */ 2397 ctx->cleanup = store->cleanup; 2398 } else 2399 ctx->cleanup = 0; 2400 2401 if (ret) 2402 ret = X509_VERIFY_PARAM_inherit(ctx->param, 2403 X509_VERIFY_PARAM_lookup("default")); 2404 2405 if (ret == 0) { 2406 X509err(X509_F_X509_STORE_CTX_INIT, ERR_R_MALLOC_FAILURE); 2407 goto err; 2408 } 2409 2410 if (store && store->check_issued) 2411 ctx->check_issued = store->check_issued; 2412 else 2413 ctx->check_issued = check_issued; 2414 2415 if (store && store->get_issuer) 2416 ctx->get_issuer = store->get_issuer; 2417 else 2418 ctx->get_issuer = X509_STORE_CTX_get1_issuer; 2419 2420 if (store && store->verify_cb) 2421 ctx->verify_cb = store->verify_cb; 2422 else 2423 ctx->verify_cb = null_callback; 2424 2425 if (store && store->verify) 2426 ctx->verify = store->verify; 2427 else 2428 ctx->verify = internal_verify; 2429 2430 if (store && store->check_revocation) 2431 ctx->check_revocation = store->check_revocation; 2432 else 2433 ctx->check_revocation = check_revocation; 2434 2435 if (store && store->get_crl) 2436 ctx->get_crl = store->get_crl; 2437 else 2438 ctx->get_crl = NULL; 2439 2440 if (store && store->check_crl) 2441 ctx->check_crl = store->check_crl; 2442 else 2443 ctx->check_crl = check_crl; 2444 2445 if (store && store->cert_crl) 2446 ctx->cert_crl = store->cert_crl; 2447 else 2448 ctx->cert_crl = cert_crl; 2449 2450 if (store && store->lookup_certs) 2451 ctx->lookup_certs = store->lookup_certs; 2452 else 2453 ctx->lookup_certs = X509_STORE_get1_certs; 2454 2455 if (store && store->lookup_crls) 2456 ctx->lookup_crls = store->lookup_crls; 2457 else 2458 ctx->lookup_crls = X509_STORE_get1_crls; 2459 2460 ctx->check_policy = check_policy; 2461 2462 if (CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx, 2463 &ctx->ex_data)) 2464 return 1; 2465 X509err(X509_F_X509_STORE_CTX_INIT, ERR_R_MALLOC_FAILURE); 2466 2467 err: 2468 /* 2469 * On error clean up allocated storage, if the store context was not 2470 * allocated with X509_STORE_CTX_new() this is our last chance to do so. 2471 */ 2472 X509_STORE_CTX_cleanup(ctx); 2473 return 0; 2474} 2475 2476/* 2477 * Set alternative lookup method: just a STACK of trusted certificates. This 2478 * avoids X509_STORE nastiness where it isn't needed. 2479 */ 2480 2481void X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk) 2482{ 2483 ctx->other_ctx = sk; 2484 ctx->get_issuer = get_issuer_sk; 2485} 2486 2487void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx) 2488{ 2489 /* 2490 * We need to be idempotent because, unfortunately, free() also calls 2491 * cleanup(), so the natural call sequence new(), init(), cleanup(), free() 2492 * calls cleanup() for the same object twice! Thus we must zero the 2493 * pointers below after they're freed! 2494 */ 2495 /* Seems to always be 0 in OpenSSL, do this at most once. */ 2496 if (ctx->cleanup != NULL) { 2497 ctx->cleanup(ctx); 2498 ctx->cleanup = NULL; 2499 } 2500 if (ctx->param != NULL) { 2501 if (ctx->parent == NULL) 2502 X509_VERIFY_PARAM_free(ctx->param); 2503 ctx->param = NULL; 2504 } 2505 if (ctx->tree != NULL) { 2506 X509_policy_tree_free(ctx->tree); 2507 ctx->tree = NULL; 2508 } 2509 if (ctx->chain != NULL) { 2510 sk_X509_pop_free(ctx->chain, X509_free); 2511 ctx->chain = NULL; 2512 } 2513 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx, &(ctx->ex_data)); 2514 memset(&ctx->ex_data, 0, sizeof(CRYPTO_EX_DATA)); 2515} 2516 2517void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth) 2518{ 2519 X509_VERIFY_PARAM_set_depth(ctx->param, depth); 2520} 2521 2522void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags) 2523{ 2524 X509_VERIFY_PARAM_set_flags(ctx->param, flags); 2525} 2526 2527void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, 2528 time_t t) 2529{ 2530 X509_VERIFY_PARAM_set_time(ctx->param, t); 2531} 2532 2533void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx, 2534 int (*verify_cb) (int, X509_STORE_CTX *)) 2535{ 2536 ctx->verify_cb = verify_cb; 2537} 2538 2539X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx) 2540{ 2541 return ctx->tree; 2542} 2543 2544int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx) 2545{ 2546 return ctx->explicit_policy; 2547} 2548 2549int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name) 2550{ 2551 const X509_VERIFY_PARAM *param; 2552 param = X509_VERIFY_PARAM_lookup(name); 2553 if (!param) 2554 return 0; 2555 return X509_VERIFY_PARAM_inherit(ctx->param, param); 2556} 2557 2558X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx) 2559{ 2560 return ctx->param; 2561} 2562 2563void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param) 2564{ 2565 if (ctx->param) 2566 X509_VERIFY_PARAM_free(ctx->param); 2567 ctx->param = param; 2568} 2569 2570IMPLEMENT_STACK_OF(X509) 2571 2572IMPLEMENT_ASN1_SET_OF(X509) 2573 2574IMPLEMENT_STACK_OF(X509_NAME) 2575 2576IMPLEMENT_STACK_OF(X509_ATTRIBUTE) 2577 2578IMPLEMENT_ASN1_SET_OF(X509_ATTRIBUTE) 2579