crypto/x509/x509_vfy.c

   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
  73 static int null_callback(int ok,X509_STORE_CTX *e);
  74 static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer);
  75 static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x);
  76 static int check_chain_purpose(X509_STORE_CTX *ctx);
  77 static int check_trust(X509_STORE_CTX *ctx);
  78 static int internal_verify(X509_STORE_CTX *ctx);
  79 const char *X509_version="X.509" OPENSSL_VERSION_PTEXT;
  80
  81 static STACK_OF(CRYPTO_EX_DATA_FUNCS) *x509_store_ctx_method=NULL;
  82 static int x509_store_ctx_num=0;
  83 #if 0
  84 static int x509_store_num=1;
  85 static STACK *x509_store_method=NULL;
  86 #endif
  87
  88 static int null_callback(int ok, X509_STORE_CTX *e)
  89         {
  90         return ok;
  91         }
  92
  93 #if 0
  94 static int x509_subject_cmp(X509 **a, X509 **b)
  95         {
  96         return X509_subject_name_cmp(*a,*b);
  97         }
  98 #endif
  99
 100 int X509_verify_cert(X509_STORE_CTX *ctx)
 101         {
 102         X509 *x,*xtmp,*chain_ss=NULL;
 103         X509_NAME *xn;
 104         int depth,i,ok=0;
 105         int num;
 106         int (*cb)();
 107         STACK_OF(X509) *sktmp=NULL;
 108
 109         if (ctx->cert == NULL)
 110                 {
 111                 X509err(X509_F_X509_VERIFY_CERT,X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);
 112                 return -1;
 113                 }
 114
 115         cb=ctx->verify_cb;
 116         if (cb == NULL) cb=null_callback;
 117
 118         /* first we make sure the chain we are going to build is
 119          * present and that the first entry is in place */
 120         if (ctx->chain == NULL)
 121                 {
 122                 if (    ((ctx->chain=sk_X509_new_null()) == NULL) ||
 123                         (!sk_X509_push(ctx->chain,ctx->cert)))
 124                         {
 125                         X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
 126                         goto end;
 127                         }
 128                 CRYPTO_add(&ctx->cert->references,1,CRYPTO_LOCK_X509);
 129                 ctx->last_untrusted=1;
 130                 }
 131
 132         /* We use a temporary STACK so we can chop and hack at it */
 133         if (ctx->untrusted != NULL
 134             && (sktmp=sk_X509_dup(ctx->untrusted)) == NULL)
 135                 {
 136                 X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
 137                 goto end;
 138                 }
 139
 140         num=sk_X509_num(ctx->chain);
 141         x=sk_X509_value(ctx->chain,num-1);
 142         depth=ctx->depth;
 143
 144
 145         for (;;)
 146                 {
 147                 /* If we have enough, we break */
 148                 if (depth < num) break; /* FIXME: If this happens, we should take
 149                                          * note of it and, if appropriate, use the
 150                                          * X509_V_ERR_CERT_CHAIN_TOO_LONG error
 151                                          * code later.
 152                                          */
 153
 154                 /* If we are self signed, we break */
 155                 xn=X509_get_issuer_name(x);
 156                 if (ctx->check_issued(ctx, x,x)) break;
 157
 158                 /* If we were passed a cert chain, use it first */
 159                 if (ctx->untrusted != NULL)
 160                         {
 161                         xtmp=find_issuer(ctx, sktmp,x);
 162                         if (xtmp != NULL)
 163                                 {
 164                                 if (!sk_X509_push(ctx->chain,xtmp))
 165                                         {
 166                                         X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
 167                                         goto end;
 168                                         }
 169                                 CRYPTO_add(&xtmp->references,1,CRYPTO_LOCK_X509);
 170                                 sk_X509_delete_ptr(sktmp,xtmp);
 171                                 ctx->last_untrusted++;
 172                                 x=xtmp;
 173                                 num++;
 174                                 /* reparse the full chain for
 175                                  * the next one */
 176                                 continue;
 177                                 }
 178                         }
 179                 break;
 180                 }
 181
 182         /* at this point, chain should contain a list of untrusted
 183          * certificates.  We now need to add at least one trusted one,
 184          * if possible, otherwise we complain. */
 185
 186         /* Examine last certificate in chain and see if it
 187          * is self signed.
 188          */
 189
 190         i=sk_X509_num(ctx->chain);
 191         x=sk_X509_value(ctx->chain,i-1);
 192         xn = X509_get_subject_name(x);
 193         if (ctx->check_issued(ctx, x, x))
 194                 {
 195                 /* we have a self signed certificate */
 196                 if (sk_X509_num(ctx->chain) == 1)
 197                         {
 198                         /* We have a single self signed certificate: see if
 199                          * we can find it in the store. We must have an exact
 200                          * match to avoid possible impersonation.
 201                          */
 202                         ok = ctx->get_issuer(&xtmp, ctx, x);
 203                         if ((ok <= 0) || X509_cmp(x, xtmp))
 204                                 {
 205                                 ctx->error=X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;
 206                                 ctx->current_cert=x;
 207                                 ctx->error_depth=i-1;
 208                                 if (ok == 1) X509_free(xtmp);
 209                                 ok=cb(0,ctx);
 210                                 if (!ok) goto end;
 211                                 }
 212                         else
 213                                 {
 214                                 /* We have a match: replace certificate with store version
 215                                  * so we get any trust settings.
 216                                  */
 217                                 X509_free(x);
 218                                 x = xtmp;
 219                                 sk_X509_set(ctx->chain, i - 1, x);
 220                                 ctx->last_untrusted=0;
 221                                 }
 222                         }
 223                 else
 224                         {
 225                         /* extract and save self signed certificate for later use */
 226                         chain_ss=sk_X509_pop(ctx->chain);
 227                         ctx->last_untrusted--;
 228                         num--;
 229                         x=sk_X509_value(ctx->chain,num-1);
 230                         }
 231                 }
 232
 233         /* We now lookup certs from the certificate store */
 234         for (;;)
 235                 {
 236                 /* If we have enough, we break */
 237                 if (depth < num) break;
 238
 239                 /* If we are self signed, we break */
 240                 xn=X509_get_issuer_name(x);
 241                 if (ctx->check_issued(ctx,x,x)) break;
 242
 243                 ok = ctx->get_issuer(&xtmp, ctx, x);
 244
 245                 if (ok < 0) return ok;
 246                 if (ok == 0) break;
 247
 248                 x = xtmp;
 249                 if (!sk_X509_push(ctx->chain,x))
 250                         {
 251                         X509_free(xtmp);
 252                         X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
 253                         return 0;
 254                         }
 255                 num++;
 256                 }
 257
 258         /* we now have our chain, lets check it... */
 259         xn=X509_get_issuer_name(x);
 260
 261         /* Is last certificate looked up self signed? */
 262         if (!ctx->check_issued(ctx,x,x))
 263                 {
 264                 if ((chain_ss == NULL) || !ctx->check_issued(ctx, x, chain_ss))
 265                         {
 266                         if (ctx->last_untrusted >= num)
 267                                 ctx->error=X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY;
 268                         else
 269                                 ctx->error=X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;
 270                         ctx->current_cert=x;
 271                         }
 272                 else
 273                         {
 274
 275                         sk_X509_push(ctx->chain,chain_ss);
 276                         num++;
 277                         ctx->last_untrusted=num;
 278                         ctx->current_cert=chain_ss;
 279                         ctx->error=X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
 280                         chain_ss=NULL;
 281                         }
 282
 283                 ctx->error_depth=num-1;
 284                 ok=cb(0,ctx);
 285                 if (!ok) goto end;
 286                 }
 287
 288         /* We have the chain complete: now we need to check its purpose */
 289         if (ctx->purpose > 0) ok = check_chain_purpose(ctx);
 290
 291         if (!ok) goto end;
 292
 293         /* The chain extensions are OK: check trust */
 294
 295         if (ctx->trust > 0) ok = check_trust(ctx);
 296
 297         if (!ok) goto end;
 298
 299         /* We may as well copy down any DSA parameters that are required */
 300         X509_get_pubkey_parameters(NULL,ctx->chain);
 301
 302         /* At this point, we have a chain and just need to verify it */
 303         if (ctx->verify != NULL)
 304                 ok=ctx->verify(ctx);
 305         else
 306                 ok=internal_verify(ctx);
 307         if (0)
 308                 {
 309 end:
 310                 X509_get_pubkey_parameters(NULL,ctx->chain);
 311                 }
 312         if (sktmp != NULL) sk_X509_free(sktmp);
 313         if (chain_ss != NULL) X509_free(chain_ss);
 314         return ok;
 315         }
 316
 317
 318 /* Given a STACK_OF(X509) find the issuer of cert (if any)
 319  */
 320
 321 static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x)
 322 {
 323         int i;
 324         X509 *issuer;
 325         for (i = 0; i < sk_X509_num(sk); i++)
 326                 {
 327                 issuer = sk_X509_value(sk, i);
 328                 if (ctx->check_issued(ctx, x, issuer))
 329                         return issuer;
 330                 }
 331         return NULL;
 332 }
 333
 334 /* Given a possible certificate and issuer check them */
 335
 336 static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer)
 337 {
 338         int ret;
 339         ret = X509_check_issued(issuer, x);
 340         if (ret == X509_V_OK)
 341                 return 1;
 342         else
 343                 {
 344                 ctx->error = ret;
 345                 ctx->current_cert = x;
 346                 ctx->current_issuer = issuer;
 347                 if ((ctx->flags & X509_V_FLAG_CB_ISSUER_CHECK) && ctx->verify_cb)
 348                         return ctx->verify_cb(0, ctx);
 349                 else
 350                         return 0;
 351                 }
 352         return 0;
 353 }
 354
 355 /* Alternative lookup method: look from a STACK stored in other_ctx */
 356
 357 static int get_issuer_sk(X509 **issuer, X509_STORE_CTX *ctx, X509 *x)
 358 {
 359         *issuer = find_issuer(ctx, ctx->other_ctx, x);
 360         if (*issuer)
 361                 {
 362                 CRYPTO_add(&(*issuer)->references,1,CRYPTO_LOCK_X509);
 363                 return 1;
 364                 }
 365         else
 366                 return 0;
 367 }
 368
 369
 370 /* Check a certificate chains extensions for consistency
 371  * with the supplied purpose
 372  */
 373
 374 static int check_chain_purpose(X509_STORE_CTX *ctx)
 375 {
 376 #ifdef NO_CHAIN_VERIFY
 377         return 1;
 378 #else
 379         int i, ok=0;
 380         X509 *x;
 381         int (*cb)();
 382         cb=ctx->verify_cb;
 383         if (cb == NULL) cb=null_callback;
 384         /* Check all untrusted certificates */
 385         for (i = 0; i < ctx->last_untrusted; i++)
 386                 {
 387                 x = sk_X509_value(ctx->chain, i);
 388                 if (!X509_check_purpose(x, ctx->purpose, i))
 389                         {
 390                         if (i)
 391                                 ctx->error = X509_V_ERR_INVALID_CA;
 392                         else
 393                                 ctx->error = X509_V_ERR_INVALID_PURPOSE;
 394                         ctx->error_depth = i;
 395                         ctx->current_cert = x;
 396                         ok=cb(0,ctx);
 397                         if (!ok) goto end;
 398                         }
 399                 /* Check pathlen */
 400                 if ((i > 1) && (x->ex_pathlen != -1)
 401                            && (i > (x->ex_pathlen + 1)))
 402                         {
 403                         ctx->error = X509_V_ERR_PATH_LENGTH_EXCEEDED;
 404                         ctx->error_depth = i;
 405                         ctx->current_cert = x;
 406                         ok=cb(0,ctx);
 407                         if (!ok) goto end;
 408                         }
 409                 }
 410         ok = 1;
 411  end:
 412         return ok;
 413 #endif
 414 }
 415
 416 static int check_trust(X509_STORE_CTX *ctx)
 417 {
 418 #ifdef NO_CHAIN_VERIFY
 419         return 1;
 420 #else
 421         int i, ok;
 422         X509 *x;
 423         int (*cb)();
 424         cb=ctx->verify_cb;
 425         if (cb == NULL) cb=null_callback;
 426 /* For now just check the last certificate in the chain */
 427         i = sk_X509_num(ctx->chain) - 1;
 428         x = sk_X509_value(ctx->chain, i);
 429         ok = X509_check_trust(x, ctx->trust, 0);
 430         if (ok == X509_TRUST_TRUSTED)
 431                 return 1;
 432         ctx->error_depth = sk_X509_num(ctx->chain) - 1;
 433         ctx->current_cert = x;
 434         if (ok == X509_TRUST_REJECTED)
 435                 ctx->error = X509_V_ERR_CERT_REJECTED;
 436         else
 437                 ctx->error = X509_V_ERR_CERT_UNTRUSTED;
 438         ok = cb(0, ctx);
 439         return ok;
 440 #endif
 441 }
 442
 443 static int internal_verify(X509_STORE_CTX *ctx)
 444         {
 445         int i,ok=0,n;
 446         X509 *xs,*xi;
 447         EVP_PKEY *pkey=NULL;
 448         time_t *ptime;
 449         int (*cb)();
 450
 451         cb=ctx->verify_cb;
 452         if (cb == NULL) cb=null_callback;
 453
 454         n=sk_X509_num(ctx->chain);
 455         ctx->error_depth=n-1;
 456         n--;
 457         xi=sk_X509_value(ctx->chain,n);
 458         if (ctx->flags & X509_V_FLAG_USE_CHECK_TIME)
 459                 ptime = &ctx->check_time;
 460         else
 461                 ptime = NULL;
 462         if (ctx->check_issued(ctx, xi, xi))
 463                 xs=xi;
 464         else
 465                 {
 466                 if (n <= 0)
 467                         {
 468                         ctx->error=X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE;
 469                         ctx->current_cert=xi;
 470                         ok=cb(0,ctx);
 471                         goto end;
 472                         }
 473                 else
 474                         {
 475                         n--;
 476                         ctx->error_depth=n;
 477                         xs=sk_X509_value(ctx->chain,n);
 478                         }
 479                 }
 480
 481 /*      ctx->error=0;  not needed */
 482         while (n >= 0)
 483                 {
 484                 ctx->error_depth=n;
 485                 if (!xs->valid)
 486                         {
 487                         if ((pkey=X509_get_pubkey(xi)) == NULL)
 488                                 {
 489                                 ctx->error=X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
 490                                 ctx->current_cert=xi;
 491                                 ok=(*cb)(0,ctx);
 492                                 if (!ok) goto end;
 493                                 }
 494                         if (X509_verify(xs,pkey) <= 0)
 495                                 {
 496                                 ctx->error=X509_V_ERR_CERT_SIGNATURE_FAILURE;
 497                                 ctx->current_cert=xs;
 498                                 ok=(*cb)(0,ctx);
 499                                 if (!ok)
 500                                         {
 501                                         EVP_PKEY_free(pkey);
 502                                         goto end;
 503                                         }
 504                                 }
 505                         EVP_PKEY_free(pkey);
 506                         pkey=NULL;
 507
 508                         i=X509_cmp_time(X509_get_notBefore(xs), ptime);
 509                         if (i == 0)
 510                                 {
 511                                 ctx->error=X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD;
 512                                 ctx->current_cert=xs;
 513                                 ok=(*cb)(0,ctx);
 514                                 if (!ok) goto end;
 515                                 }
 516                         if (i > 0)
 517                                 {
 518                                 ctx->error=X509_V_ERR_CERT_NOT_YET_VALID;
 519                                 ctx->current_cert=xs;
 520                                 ok=(*cb)(0,ctx);
 521                                 if (!ok) goto end;
 522                                 }
 523                         xs->valid=1;
 524                         }
 525
 526                 i=X509_cmp_time(X509_get_notAfter(xs), ptime);
 527                 if (i == 0)
 528                         {
 529                         ctx->error=X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD;
 530                         ctx->current_cert=xs;
 531                         ok=(*cb)(0,ctx);
 532                         if (!ok) goto end;
 533                         }
 534
 535                 if (i < 0)
 536                         {
 537                         ctx->error=X509_V_ERR_CERT_HAS_EXPIRED;
 538                         ctx->current_cert=xs;
 539                         ok=(*cb)(0,ctx);
 540                         if (!ok) goto end;
 541                         }
 542
 543                 /* CRL CHECK */
 544
 545                 /* The last error (if any) is still in the error value */
 546                 ctx->current_cert=xs;
 547                 ok=(*cb)(1,ctx);
 548                 if (!ok) goto end;
 549
 550                 n--;
 551                 if (n >= 0)
 552                         {
 553                         xi=xs;
 554                         xs=sk_X509_value(ctx->chain,n);
 555                         }
 556                 }
 557         ok=1;
 558 end:
 559         return ok;
 560         }
 561
 562 int X509_cmp_current_time(ASN1_TIME *ctm)
 563 {
 564         return X509_cmp_time(ctm, NULL);
 565 }
 566
 567 int X509_cmp_time(ASN1_TIME *ctm, time_t *cmp_time)
 568         {
 569         char *str;
 570         ASN1_TIME atm;
 571         time_t offset;
 572         char buff1[24],buff2[24],*p;
 573         int i,j;
 574
 575         p=buff1;
 576         i=ctm->length;
 577         str=(char *)ctm->data;
 578         if (ctm->type == V_ASN1_UTCTIME)
 579                 {
 580                 if ((i < 11) || (i > 17)) return 0;
 581                 memcpy(p,str,10);
 582                 p+=10;
 583                 str+=10;
 584                 }
 585         else
 586                 {
 587                 if (i < 13) return 0;
 588                 memcpy(p,str,12);
 589                 p+=12;
 590                 str+=12;
 591                 }
 592
 593         if ((*str == 'Z') || (*str == '-') || (*str == '+'))
 594                 { *(p++)='0'; *(p++)='0'; }
 595         else
 596                 {
 597                 *(p++)= *(str++);
 598                 *(p++)= *(str++);
 599                 /* Skip any fractional seconds... */
 600                 if (*str == '.')
 601                         {
 602                         str++;
 603                         while ((*str >= '0') && (*str <= '9')) str++;
 604                         }
 605
 606                 }
 607         *(p++)='Z';
 608         *(p++)='\0';
 609
 610         if (*str == 'Z')
 611                 offset=0;
 612         else
 613                 {
 614                 if ((*str != '+') && (str[5] != '-'))
 615                         return 0;
 616                 offset=((str[1]-'0')*10+(str[2]-'0'))*60;
 617                 offset+=(str[3]-'0')*10+(str[4]-'0');
 618                 if (*str == '-')
 619                         offset= -offset;
 620                 }
 621         atm.type=ctm->type;
 622         atm.length=sizeof(buff2);
 623         atm.data=(unsigned char *)buff2;
 624
 625         X509_time_adj(&atm,-offset*60, cmp_time);
 626
 627         if (ctm->type == V_ASN1_UTCTIME)
 628                 {
 629                 i=(buff1[0]-'0')*10+(buff1[1]-'0');
 630                 if (i < 50) i+=100; /* cf. RFC 2459 */
 631                 j=(buff2[0]-'0')*10+(buff2[1]-'0');
 632                 if (j < 50) j+=100;
 633
 634                 if (i < j) return -1;
 635                 if (i > j) return 1;
 636                 }
 637         i=strcmp(buff1,buff2);
 638         if (i == 0) /* wait a second then return younger :-) */
 639                 return -1;
 640         else
 641                 return i;
 642         }
 643
 644 ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj)
 645 {
 646         return X509_time_adj(s, adj, NULL);
 647 }
 648
 649 ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *in_tm)
 650         {
 651         time_t t;
 652
 653         if (in_tm) t = *in_tm;
 654         else time(&t);
 655
 656         t+=adj;
 657         if (!s) return ASN1_TIME_set(s, t);
 658         if (s->type == V_ASN1_UTCTIME) return ASN1_UTCTIME_set(s,t);
 659         return ASN1_GENERALIZEDTIME_set(s, t);
 660         }
 661
 662 int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
 663         {
 664         EVP_PKEY *ktmp=NULL,*ktmp2;
 665         int i,j;
 666
 667         if ((pkey != NULL) && !EVP_PKEY_missing_parameters(pkey)) return 1;
 668
 669         for (i=0; i<sk_X509_num(chain); i++)
 670                 {
 671                 ktmp=X509_get_pubkey(sk_X509_value(chain,i));
 672                 if (ktmp == NULL)
 673                         {
 674                         X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY);
 675                         return 0;
 676                         }
 677                 if (!EVP_PKEY_missing_parameters(ktmp))
 678                         break;
 679                 else
 680                         {
 681                         EVP_PKEY_free(ktmp);
 682                         ktmp=NULL;
 683                         }
 684                 }
 685         if (ktmp == NULL)
 686                 {
 687                 X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN);
 688                 return 0;
 689                 }
 690
 691         /* first, populate the other certs */
 692         for (j=i-1; j >= 0; j--)
 693                 {
 694                 ktmp2=X509_get_pubkey(sk_X509_value(chain,j));
 695                 EVP_PKEY_copy_parameters(ktmp2,ktmp);
 696                 EVP_PKEY_free(ktmp2);
 697                 }
 698
 699         if (pkey != NULL) EVP_PKEY_copy_parameters(pkey,ktmp);
 700         EVP_PKEY_free(ktmp);
 701         return 1;
 702         }
 703
 704 int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 705              CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
 706         {
 707         x509_store_ctx_num++;
 708         return CRYPTO_get_ex_new_index(x509_store_ctx_num-1,
 709                 &x509_store_ctx_method,
 710                 argl,argp,new_func,dup_func,free_func);
 711         }
 712
 713 int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
 714         {
 715         return CRYPTO_set_ex_data(&ctx->ex_data,idx,data);
 716         }
 717
 718 void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
 719         {
 720         return CRYPTO_get_ex_data(&ctx->ex_data,idx);
 721         }
 722
 723 int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
 724         {
 725         return ctx->error;
 726         }
 727
 728 void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
 729         {
 730         ctx->error=err;
 731         }
 732
 733 int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
 734         {
 735         return ctx->error_depth;
 736         }
 737
 738 X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
 739         {
 740         return ctx->current_cert;
 741         }
 742
 743 STACK_OF(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
 744         {
 745         return ctx->chain;
 746         }
 747
 748 STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
 749         {
 750         int i;
 751         X509 *x;
 752         STACK_OF(X509) *chain;
 753         if (!ctx->chain || !(chain = sk_X509_dup(ctx->chain))) return NULL;
 754         for (i = 0; i < sk_X509_num(chain); i++)
 755                 {
 756                 x = sk_X509_value(chain, i);
 757                 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
 758                 }
 759         return chain;
 760         }
 761
 762 void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
 763         {
 764         ctx->cert=x;
 765         }
 766
 767 void X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 768         {
 769         ctx->untrusted=sk;
 770         }
 771
 772 int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose)
 773         {
 774         return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0);
 775         }
 776
 777 int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust)
 778         {
 779         return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust);
 780         }
 781
 782 /* This function is used to set the X509_STORE_CTX purpose and trust
 783  * values. This is intended to be used when another structure has its
 784  * own trust and purpose values which (if set) will be inherited by
 785  * the ctx. If they aren't set then we will usually have a default
 786  * purpose in mind which should then be used to set the trust value.
 787  * An example of this is SSL use: an SSL structure will have its own
 788  * purpose and trust settings which the application can set: if they
 789  * aren't set then we use the default of SSL client/server.
 790  */
 791
 792 int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
 793                                 int purpose, int trust)
 794 {
 795         int idx;
 796         /* If purpose not set use default */
 797         if (!purpose) purpose = def_purpose;
 798         /* If we have a purpose then check it is valid */
 799         if (purpose)
 800                 {
 801                 X509_PURPOSE *ptmp;
 802                 idx = X509_PURPOSE_get_by_id(purpose);
 803                 if (idx == -1)
 804                         {
 805                         X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
 806                                                 X509_R_UNKNOWN_PURPOSE_ID);
 807                         return 0;
 808                         }
 809                 ptmp = X509_PURPOSE_get0(idx);
 810                 if (ptmp->trust == X509_TRUST_DEFAULT)
 811                         {
 812                         idx = X509_PURPOSE_get_by_id(def_purpose);
 813                         if (idx == -1)
 814                                 {
 815                                 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
 816                                                 X509_R_UNKNOWN_PURPOSE_ID);
 817                                 return 0;
 818                                 }
 819                         ptmp = X509_PURPOSE_get0(idx);
 820                         }
 821                 /* If trust not set then get from purpose default */
 822                 if (!trust) trust = ptmp->trust;
 823                 }
 824         if (trust)
 825                 {
 826                 idx = X509_TRUST_get_by_id(trust);
 827                 if (idx == -1)
 828                         {
 829                         X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
 830                                                 X509_R_UNKNOWN_TRUST_ID);
 831                         return 0;
 832                         }
 833                 }
 834
 835         if (purpose) ctx->purpose = purpose;
 836         if (trust) ctx->trust = trust;
 837         return 1;
 838 }
 839
 840 X509_STORE_CTX *X509_STORE_CTX_new(void)
 841 {
 842         X509_STORE_CTX *ctx;
 843         ctx = (X509_STORE_CTX *)OPENSSL_malloc(sizeof(X509_STORE_CTX));
 844         if (ctx) memset(ctx, 0, sizeof(X509_STORE_CTX));
 845         return ctx;
 846 }
 847
 848 void X509_STORE_CTX_free(X509_STORE_CTX *ctx)
 849 {
 850         X509_STORE_CTX_cleanup(ctx);
 851         OPENSSL_free(ctx);
 852 }
 853
 854 void X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
 855              STACK_OF(X509) *chain)
 856         {
 857         ctx->ctx=store;
 858         ctx->current_method=0;
 859         ctx->cert=x509;
 860         ctx->untrusted=chain;
 861         ctx->last_untrusted=0;
 862         ctx->purpose=0;
 863         ctx->trust=0;
 864         ctx->check_time=0;
 865         ctx->flags=0;
 866         ctx->other_ctx=NULL;
 867         ctx->valid=0;
 868         ctx->chain=NULL;
 869         ctx->depth=9;
 870         ctx->error=0;
 871         ctx->error_depth=0;
 872         ctx->current_cert=NULL;
 873         ctx->current_issuer=NULL;
 874         ctx->check_issued = check_issued;
 875         ctx->get_issuer = X509_STORE_CTX_get1_issuer;
 876         ctx->verify_cb = store->verify_cb;
 877         ctx->verify = store->verify;
 878         ctx->cleanup = 0;
 879         memset(&(ctx->ex_data),0,sizeof(CRYPTO_EX_DATA));
 880         }
 881
 882 /* Set alternative lookup method: just a STACK of trusted certificates.
 883  * This avoids X509_STORE nastiness where it isn't needed.
 884  */
 885
 886 void X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 887 {
 888         ctx->other_ctx = sk;
 889         ctx->get_issuer = get_issuer_sk;
 890 }
 891
 892 void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
 893         {
 894         if (ctx->cleanup) ctx->cleanup(ctx);
 895         if (ctx->chain != NULL)
 896                 {
 897                 sk_X509_pop_free(ctx->chain,X509_free);
 898                 ctx->chain=NULL;
 899                 }
 900         CRYPTO_free_ex_data(x509_store_ctx_method,ctx,&(ctx->ex_data));
 901         memset(&ctx->ex_data,0,sizeof(CRYPTO_EX_DATA));
 902         }
 903
 904 void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, long flags)
 905         {
 906         ctx->flags |= flags;
 907         }
 908
 909 void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, long flags, time_t t)
 910         {
 911         ctx->check_time = t;
 912         ctx->flags |= X509_V_FLAG_USE_CHECK_TIME;
 913         }
 914
 915 IMPLEMENT_STACK_OF(X509)
 916 IMPLEMENT_ASN1_SET_OF(X509)
 917
 918 IMPLEMENT_STACK_OF(X509_NAME)
 919
 920 IMPLEMENT_STACK_OF(X509_ATTRIBUTE)
 921 IMPLEMENT_ASN1_SET_OF(X509_ATTRIBUTE)