a2c884e49799392b11798c3edecd27ab6e715543
[openssl.git] / 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 check_revocation(X509_STORE_CTX *ctx);
79 static int check_cert(X509_STORE_CTX *ctx);
80 static int check_policy(X509_STORE_CTX *ctx);
81 static int internal_verify(X509_STORE_CTX *ctx);
82 const char *X509_version="X.509" OPENSSL_VERSION_PTEXT;
83
84
85 static int null_callback(int ok, X509_STORE_CTX *e)
86         {
87         return ok;
88         }
89
90 #if 0
91 static int x509_subject_cmp(X509 **a, X509 **b)
92         {
93         return X509_subject_name_cmp(*a,*b);
94         }
95 #endif
96
97 int X509_verify_cert(X509_STORE_CTX *ctx)
98         {
99         X509 *x,*xtmp,*chain_ss=NULL;
100         X509_NAME *xn;
101         int bad_chain = 0;
102         X509_VERIFY_PARAM *param = ctx->param;
103         int depth,i,ok=0;
104         int num;
105         int (*cb)();
106         STACK_OF(X509) *sktmp=NULL;
107         if (ctx->cert == NULL)
108                 {
109                 X509err(X509_F_X509_VERIFY_CERT,X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);
110                 return -1;
111                 }
112
113         cb=ctx->verify_cb;
114
115         /* first we make sure the chain we are going to build is
116          * present and that the first entry is in place */
117         if (ctx->chain == NULL)
118                 {
119                 if (    ((ctx->chain=sk_X509_new_null()) == NULL) ||
120                         (!sk_X509_push(ctx->chain,ctx->cert)))
121                         {
122                         X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
123                         goto end;
124                         }
125                 CRYPTO_add(&ctx->cert->references,1,CRYPTO_LOCK_X509);
126                 ctx->last_untrusted=1;
127                 }
128
129         /* We use a temporary STACK so we can chop and hack at it */
130         if (ctx->untrusted != NULL
131             && (sktmp=sk_X509_dup(ctx->untrusted)) == NULL)
132                 {
133                 X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
134                 goto end;
135                 }
136
137         num=sk_X509_num(ctx->chain);
138         x=sk_X509_value(ctx->chain,num-1);
139         depth=param->depth;
140
141
142         for (;;)
143                 {
144                 /* If we have enough, we break */
145                 if (depth < num) break; /* FIXME: If this happens, we should take
146                                          * note of it and, if appropriate, use the
147                                          * X509_V_ERR_CERT_CHAIN_TOO_LONG error
148                                          * code later.
149                                          */
150
151                 /* If we are self signed, we break */
152                 xn=X509_get_issuer_name(x);
153                 if (ctx->check_issued(ctx, x,x)) break;
154
155                 /* If we were passed a cert chain, use it first */
156                 if (ctx->untrusted != NULL)
157                         {
158                         xtmp=find_issuer(ctx, sktmp,x);
159                         if (xtmp != NULL)
160                                 {
161                                 if (!sk_X509_push(ctx->chain,xtmp))
162                                         {
163                                         X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
164                                         goto end;
165                                         }
166                                 CRYPTO_add(&xtmp->references,1,CRYPTO_LOCK_X509);
167                                 sk_X509_delete_ptr(sktmp,xtmp);
168                                 ctx->last_untrusted++;
169                                 x=xtmp;
170                                 num++;
171                                 /* reparse the full chain for
172                                  * the next one */
173                                 continue;
174                                 }
175                         }
176                 break;
177                 }
178
179         /* at this point, chain should contain a list of untrusted
180          * certificates.  We now need to add at least one trusted one,
181          * if possible, otherwise we complain. */
182
183         /* Examine last certificate in chain and see if it
184          * is self signed.
185          */
186
187         i=sk_X509_num(ctx->chain);
188         x=sk_X509_value(ctx->chain,i-1);
189         xn = X509_get_subject_name(x);
190         if (ctx->check_issued(ctx, x, x))
191                 {
192                 /* we have a self signed certificate */
193                 if (sk_X509_num(ctx->chain) == 1)
194                         {
195                         /* We have a single self signed certificate: see if
196                          * we can find it in the store. We must have an exact
197                          * match to avoid possible impersonation.
198                          */
199                         ok = ctx->get_issuer(&xtmp, ctx, x);
200                         if ((ok <= 0) || X509_cmp(x, xtmp)) 
201                                 {
202                                 ctx->error=X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;
203                                 ctx->current_cert=x;
204                                 ctx->error_depth=i-1;
205                                 if (ok == 1) X509_free(xtmp);
206                                 bad_chain = 1;
207                                 ok=cb(0,ctx);
208                                 if (!ok) goto end;
209                                 }
210                         else 
211                                 {
212                                 /* We have a match: replace certificate with store version
213                                  * so we get any trust settings.
214                                  */
215                                 X509_free(x);
216                                 x = xtmp;
217                                 sk_X509_set(ctx->chain, i - 1, x);
218                                 ctx->last_untrusted=0;
219                                 }
220                         }
221                 else
222                         {
223                         /* extract and save self signed certificate for later use */
224                         chain_ss=sk_X509_pop(ctx->chain);
225                         ctx->last_untrusted--;
226                         num--;
227                         x=sk_X509_value(ctx->chain,num-1);
228                         }
229                 }
230
231         /* We now lookup certs from the certificate store */
232         for (;;)
233                 {
234                 /* If we have enough, we break */
235                 if (depth < num) break;
236
237                 /* If we are self signed, we break */
238                 xn=X509_get_issuer_name(x);
239                 if (ctx->check_issued(ctx,x,x)) break;
240
241                 ok = ctx->get_issuer(&xtmp, ctx, x);
242
243                 if (ok < 0) return ok;
244                 if (ok == 0) break;
245
246                 x = xtmp;
247                 if (!sk_X509_push(ctx->chain,x))
248                         {
249                         X509_free(xtmp);
250                         X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
251                         return 0;
252                         }
253                 num++;
254                 }
255
256         /* we now have our chain, lets check it... */
257         xn=X509_get_issuer_name(x);
258
259         /* Is last certificate looked up self signed? */
260         if (!ctx->check_issued(ctx,x,x))
261                 {
262                 if ((chain_ss == NULL) || !ctx->check_issued(ctx, x, chain_ss))
263                         {
264                         if (ctx->last_untrusted >= num)
265                                 ctx->error=X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY;
266                         else
267                                 ctx->error=X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;
268                         ctx->current_cert=x;
269                         }
270                 else
271                         {
272
273                         sk_X509_push(ctx->chain,chain_ss);
274                         num++;
275                         ctx->last_untrusted=num;
276                         ctx->current_cert=chain_ss;
277                         ctx->error=X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
278                         chain_ss=NULL;
279                         }
280
281                 ctx->error_depth=num-1;
282                 bad_chain = 1;
283                 ok=cb(0,ctx);
284                 if (!ok) goto end;
285                 }
286
287         /* We have the chain complete: now we need to check its purpose */
288         if (param->purpose > 0) ok = check_chain_purpose(ctx);
289
290         if (!ok) goto end;
291
292         /* The chain extensions are OK: check trust */
293
294         if (param->trust > 0) ok = check_trust(ctx);
295
296         if (!ok) goto end;
297
298         /* We may as well copy down any DSA parameters that are required */
299         X509_get_pubkey_parameters(NULL,ctx->chain);
300
301         /* Check revocation status: we do this after copying parameters
302          * because they may be needed for CRL signature verification.
303          */
304
305         ok = ctx->check_revocation(ctx);
306         if(!ok) goto end;
307
308         /* At this point, we have a chain and need to verify it */
309         if (ctx->verify != NULL)
310                 ok=ctx->verify(ctx);
311         else
312                 ok=internal_verify(ctx);
313         if(!ok) goto end;
314
315         /* If we get this far evaluate policies */
316         if (!bad_chain && (ctx->param->flags & X509_V_FLAG_POLICY_CHECK))
317                 ok = ctx->check_policy(ctx);
318         if(!ok) goto end;
319         if (0)
320                 {
321 end:
322                 X509_get_pubkey_parameters(NULL,ctx->chain);
323                 }
324         if (sktmp != NULL) sk_X509_free(sktmp);
325         if (chain_ss != NULL) X509_free(chain_ss);
326         return ok;
327         }
328
329
330 /* Given a STACK_OF(X509) find the issuer of cert (if any)
331  */
332
333 static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x)
334 {
335         int i;
336         X509 *issuer;
337         for (i = 0; i < sk_X509_num(sk); i++)
338                 {
339                 issuer = sk_X509_value(sk, i);
340                 if (ctx->check_issued(ctx, x, issuer))
341                         return issuer;
342                 }
343         return NULL;
344 }
345
346 /* Given a possible certificate and issuer check them */
347
348 static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer)
349 {
350         int ret;
351         ret = X509_check_issued(issuer, x);
352         if (ret == X509_V_OK)
353                 return 1;
354         /* If we haven't asked for issuer errors don't set ctx */
355         if (!(ctx->param->flags & X509_V_FLAG_CB_ISSUER_CHECK))
356                 return 0;
357
358         ctx->error = ret;
359         ctx->current_cert = x;
360         ctx->current_issuer = issuer;
361         return ctx->verify_cb(0, ctx);
362         return 0;
363 }
364
365 /* Alternative lookup method: look from a STACK stored in other_ctx */
366
367 static int get_issuer_sk(X509 **issuer, X509_STORE_CTX *ctx, X509 *x)
368 {
369         *issuer = find_issuer(ctx, ctx->other_ctx, x);
370         if (*issuer)
371                 {
372                 CRYPTO_add(&(*issuer)->references,1,CRYPTO_LOCK_X509);
373                 return 1;
374                 }
375         else
376                 return 0;
377 }
378         
379
380 /* Check a certificate chains extensions for consistency
381  * with the supplied purpose
382  */
383
384 static int check_chain_purpose(X509_STORE_CTX *ctx)
385 {
386 #ifdef OPENSSL_NO_CHAIN_VERIFY
387         return 1;
388 #else
389         int i, ok=0;
390         X509 *x;
391         int (*cb)();
392         cb=ctx->verify_cb;
393         /* Check all untrusted certificates */
394         for (i = 0; i < ctx->last_untrusted; i++)
395                 {
396                 int ret;
397                 x = sk_X509_value(ctx->chain, i);
398                 if (!(ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL)
399                         && (x->ex_flags & EXFLAG_CRITICAL))
400                         {
401                         ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION;
402                         ctx->error_depth = i;
403                         ctx->current_cert = x;
404                         ok=cb(0,ctx);
405                         if (!ok) goto end;
406                         }
407                 ret = X509_check_purpose(x, ctx->param->purpose, i);
408                 if ((ret == 0)
409                          || ((ctx->param->flags & X509_V_FLAG_X509_STRICT)
410                                 && (ret != 1)))
411                         {
412                         if (i)
413                                 ctx->error = X509_V_ERR_INVALID_CA;
414                         else
415                                 ctx->error = X509_V_ERR_INVALID_PURPOSE;
416                         ctx->error_depth = i;
417                         ctx->current_cert = x;
418                         ok=cb(0,ctx);
419                         if (!ok) goto end;
420                         }
421                 /* Check pathlen */
422                 if ((i > 1) && (x->ex_pathlen != -1)
423                            && (i > (x->ex_pathlen + 1)))
424                         {
425                         ctx->error = X509_V_ERR_PATH_LENGTH_EXCEEDED;
426                         ctx->error_depth = i;
427                         ctx->current_cert = x;
428                         ok=cb(0,ctx);
429                         if (!ok) goto end;
430                         }
431                 }
432         ok = 1;
433  end:
434         return ok;
435 #endif
436 }
437
438 static int check_trust(X509_STORE_CTX *ctx)
439 {
440 #ifdef OPENSSL_NO_CHAIN_VERIFY
441         return 1;
442 #else
443         int i, ok;
444         X509 *x;
445         int (*cb)();
446         cb=ctx->verify_cb;
447 /* For now just check the last certificate in the chain */
448         i = sk_X509_num(ctx->chain) - 1;
449         x = sk_X509_value(ctx->chain, i);
450         ok = X509_check_trust(x, ctx->param->trust, 0);
451         if (ok == X509_TRUST_TRUSTED)
452                 return 1;
453         ctx->error_depth = i;
454         ctx->current_cert = x;
455         if (ok == X509_TRUST_REJECTED)
456                 ctx->error = X509_V_ERR_CERT_REJECTED;
457         else
458                 ctx->error = X509_V_ERR_CERT_UNTRUSTED;
459         ok = cb(0, ctx);
460         return ok;
461 #endif
462 }
463
464 static int check_revocation(X509_STORE_CTX *ctx)
465         {
466         int i, last, ok;
467         if (!(ctx->param->flags & X509_V_FLAG_CRL_CHECK))
468                 return 1;
469         if (ctx->param->flags & X509_V_FLAG_CRL_CHECK_ALL)
470                 last = sk_X509_num(ctx->chain) - 1;
471         else
472                 last = 0;
473         for(i = 0; i <= last; i++)
474                 {
475                 ctx->error_depth = i;
476                 ok = check_cert(ctx);
477                 if (!ok) return ok;
478                 }
479         return 1;
480         }
481
482 static int check_cert(X509_STORE_CTX *ctx)
483         {
484         X509_CRL *crl = NULL;
485         X509 *x;
486         int ok, cnum;
487         cnum = ctx->error_depth;
488         x = sk_X509_value(ctx->chain, cnum);
489         ctx->current_cert = x;
490         /* Try to retrieve relevant CRL */
491         ok = ctx->get_crl(ctx, &crl, x);
492         /* If error looking up CRL, nothing we can do except
493          * notify callback
494          */
495         if(!ok)
496                 {
497                 ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL;
498                 ok = ctx->verify_cb(0, ctx);
499                 goto err;
500                 }
501         ctx->current_crl = crl;
502         ok = ctx->check_crl(ctx, crl);
503         if (!ok) goto err;
504         ok = ctx->cert_crl(ctx, crl, x);
505         err:
506         ctx->current_crl = NULL;
507         X509_CRL_free(crl);
508         return ok;
509
510         }
511
512 /* Check CRL times against values in X509_STORE_CTX */
513
514 static int check_crl_time(X509_STORE_CTX *ctx, X509_CRL *crl, int notify)
515         {
516         time_t *ptime;
517         int i;
518         ctx->current_crl = crl;
519         if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME)
520                 ptime = &ctx->param->check_time;
521         else
522                 ptime = NULL;
523
524         i=X509_cmp_time(X509_CRL_get_lastUpdate(crl), ptime);
525         if (i == 0)
526                 {
527                 ctx->error=X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD;
528                 if (!notify || !ctx->verify_cb(0, ctx))
529                         return 0;
530                 }
531
532         if (i > 0)
533                 {
534                 ctx->error=X509_V_ERR_CRL_NOT_YET_VALID;
535                 if (!notify || !ctx->verify_cb(0, ctx))
536                         return 0;
537                 }
538
539         if(X509_CRL_get_nextUpdate(crl))
540                 {
541                 i=X509_cmp_time(X509_CRL_get_nextUpdate(crl), ptime);
542
543                 if (i == 0)
544                         {
545                         ctx->error=X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD;
546                         if (!notify || !ctx->verify_cb(0, ctx))
547                                 return 0;
548                         }
549
550                 if (i < 0)
551                         {
552                         ctx->error=X509_V_ERR_CRL_HAS_EXPIRED;
553                         if (!notify || !ctx->verify_cb(0, ctx))
554                                 return 0;
555                         }
556                 }
557
558         ctx->current_crl = NULL;
559
560         return 1;
561         }
562
563 /* Lookup CRLs from the supplied list. Look for matching isser name
564  * and validity. If we can't find a valid CRL return the last one
565  * with matching name. This gives more meaningful error codes. Otherwise
566  * we'd get a CRL not found error if a CRL existed with matching name but
567  * was invalid.
568  */
569
570 static int get_crl_sk(X509_STORE_CTX *ctx, X509_CRL **pcrl,
571                         X509_NAME *nm, STACK_OF(X509_CRL) *crls)
572         {
573         int i;
574         X509_CRL *crl, *best_crl = NULL;
575         for (i = 0; i < sk_X509_CRL_num(crls); i++)
576                 {
577                 crl = sk_X509_CRL_value(crls, i);
578                 if (X509_NAME_cmp(nm, X509_CRL_get_issuer(crl)))
579                         continue;
580                 if (check_crl_time(ctx, crl, 0))
581                         {
582                         *pcrl = crl;
583                         CRYPTO_add(&crl->references, 1, CRYPTO_LOCK_X509);
584                         return 1;
585                         }
586                 best_crl = crl;
587                 }
588         if (best_crl)
589                 {
590                 *pcrl = best_crl;
591                 CRYPTO_add(&best_crl->references, 1, CRYPTO_LOCK_X509);
592                 }
593                 
594         return 0;
595         }
596
597 /* Retrieve CRL corresponding to certificate: currently just a
598  * subject lookup: maybe use AKID later...
599  */
600 static int get_crl(X509_STORE_CTX *ctx, X509_CRL **pcrl, X509 *x)
601         {
602         int ok;
603         X509_CRL *crl = NULL;
604         X509_OBJECT xobj;
605         X509_NAME *nm;
606         nm = X509_get_issuer_name(x);
607         ok = get_crl_sk(ctx, &crl, nm, ctx->crls);
608         if (ok)
609                 {
610                 *pcrl = crl;
611                 return 1;
612                 }
613
614         ok = X509_STORE_get_by_subject(ctx, X509_LU_CRL, nm, &xobj);
615
616         if (!ok)
617                 {
618                 /* If we got a near match from get_crl_sk use that */
619                 if (crl)
620                         {
621                         *pcrl = crl;
622                         return 1;
623                         }
624                 return 0;
625                 }
626
627         *pcrl = xobj.data.crl;
628         if (crl)
629                 X509_CRL_free(crl);
630         return 1;
631         }
632
633 /* Check CRL validity */
634 static int check_crl(X509_STORE_CTX *ctx, X509_CRL *crl)
635         {
636         X509 *issuer = NULL;
637         EVP_PKEY *ikey = NULL;
638         int ok = 0, chnum, cnum;
639         cnum = ctx->error_depth;
640         chnum = sk_X509_num(ctx->chain) - 1;
641         /* Find CRL issuer: if not last certificate then issuer
642          * is next certificate in chain.
643          */
644         if(cnum < chnum)
645                 issuer = sk_X509_value(ctx->chain, cnum + 1);
646         else
647                 {
648                 issuer = sk_X509_value(ctx->chain, chnum);
649                 /* If not self signed, can't check signature */
650                 if(!ctx->check_issued(ctx, issuer, issuer))
651                         {
652                         ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER;
653                         ok = ctx->verify_cb(0, ctx);
654                         if(!ok) goto err;
655                         }
656                 }
657
658         if(issuer)
659                 {
660                 /* Check for cRLSign bit if keyUsage present */
661                 if ((issuer->ex_flags & EXFLAG_KUSAGE) &&
662                         !(issuer->ex_kusage & KU_CRL_SIGN))
663                         {
664                         ctx->error = X509_V_ERR_KEYUSAGE_NO_CRL_SIGN;
665                         ok = ctx->verify_cb(0, ctx);
666                         if(!ok) goto err;
667                         }
668
669                 /* Attempt to get issuer certificate public key */
670                 ikey = X509_get_pubkey(issuer);
671
672                 if(!ikey)
673                         {
674                         ctx->error=X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
675                         ok = ctx->verify_cb(0, ctx);
676                         if (!ok) goto err;
677                         }
678                 else
679                         {
680                         /* Verify CRL signature */
681                         if(X509_CRL_verify(crl, ikey) <= 0)
682                                 {
683                                 ctx->error=X509_V_ERR_CRL_SIGNATURE_FAILURE;
684                                 ok = ctx->verify_cb(0, ctx);
685                                 if (!ok) goto err;
686                                 }
687                         }
688                 }
689
690         if (!check_crl_time(ctx, crl, 1))
691                 goto err;
692
693         ok = 1;
694
695         err:
696         EVP_PKEY_free(ikey);
697         return ok;
698         }
699
700 /* Check certificate against CRL */
701 static int cert_crl(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x)
702         {
703         int idx, ok;
704         X509_REVOKED rtmp;
705         STACK_OF(X509_EXTENSION) *exts;
706         X509_EXTENSION *ext;
707         /* Look for serial number of certificate in CRL */
708         rtmp.serialNumber = X509_get_serialNumber(x);
709         idx = sk_X509_REVOKED_find(crl->crl->revoked, &rtmp);
710         /* If found assume revoked: want something cleverer than
711          * this to handle entry extensions in V2 CRLs.
712          */
713         if(idx >= 0)
714                 {
715                 ctx->error = X509_V_ERR_CERT_REVOKED;
716                 ok = ctx->verify_cb(0, ctx);
717                 if (!ok) return 0;
718                 }
719
720         if (ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL)
721                 return 1;
722
723         /* See if we have any critical CRL extensions: since we
724          * currently don't handle any CRL extensions the CRL must be
725          * rejected. 
726          * This code accesses the X509_CRL structure directly: applications
727          * shouldn't do this.
728          */
729
730         exts = crl->crl->extensions;
731
732         for (idx = 0; idx < sk_X509_EXTENSION_num(exts); idx++)
733                 {
734                 ext = sk_X509_EXTENSION_value(exts, idx);
735                 if (ext->critical > 0)
736                         {
737                         ctx->error =
738                                 X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION;
739                         ok = ctx->verify_cb(0, ctx);
740                         if(!ok) return 0;
741                         break;
742                         }
743                 }
744         return 1;
745         }
746
747 static int check_policy(X509_STORE_CTX *ctx)
748         {
749         int ret;
750         ret = X509_policy_check(&ctx->tree, &ctx->explicit_policy, ctx->chain,
751                                 ctx->param->policies, ctx->param->flags);
752         if (ret == 0)
753                 {
754                 X509err(X509_F_X509_VERIFY_CERT,ERR_R_MALLOC_FAILURE);
755                 return 0;
756                 }
757         /* Invalid or inconsistent extensions */
758         if (ret == -1)
759                 {
760                 /* Locate certificates with bad extensions and notify
761                  * callback.
762                  */
763                 X509 *x;
764                 int i;
765                 for (i = 1; i < sk_X509_num(ctx->chain); i++)
766                         {
767                         x = sk_X509_value(ctx->chain, i);
768                         if (!(x->ex_flags & EXFLAG_INVALID_POLICY))
769                                 continue;
770                         ctx->current_cert = x;
771                         ctx->error = X509_V_ERR_INVALID_POLICY_EXTENSION;
772                         ret = ctx->verify_cb(0, ctx);
773                         }
774                 return 1;
775                 }
776         if (ret == -2)
777                 {
778                 ctx->current_cert = NULL;
779                 ctx->error = X509_V_ERR_NO_EXPLICIT_POLICY;
780                 return ctx->verify_cb(0, ctx);
781                 }
782
783         if (ctx->param->flags & X509_V_FLAG_NOTIFY_POLICY)
784                 {
785                 ctx->current_cert = NULL;
786                 ctx->error = X509_V_OK;
787                 if (!ctx->verify_cb(2, ctx))
788                         return 0;
789                 }
790
791         return 1;
792         }
793
794 static int check_cert_time(X509_STORE_CTX *ctx, X509 *x)
795         {
796         time_t *ptime;
797         int i;
798
799         if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME)
800                 ptime = &ctx->param->check_time;
801         else
802                 ptime = NULL;
803
804         i=X509_cmp_time(X509_get_notBefore(x), ptime);
805         if (i == 0)
806                 {
807                 ctx->error=X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD;
808                 ctx->current_cert=x;
809                 if (!ctx->verify_cb(0, ctx))
810                         return 0;
811                 }
812
813         if (i > 0)
814                 {
815                 ctx->error=X509_V_ERR_CERT_NOT_YET_VALID;
816                 ctx->current_cert=x;
817                 if (!ctx->verify_cb(0, ctx))
818                         return 0;
819                 }
820
821         i=X509_cmp_time(X509_get_notAfter(x), ptime);
822         if (i == 0)
823                 {
824                 ctx->error=X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD;
825                 ctx->current_cert=x;
826                 if (!ctx->verify_cb(0, ctx))
827                         return 0;
828                 }
829
830         if (i < 0)
831                 {
832                 ctx->error=X509_V_ERR_CERT_HAS_EXPIRED;
833                 ctx->current_cert=x;
834                 if (!ctx->verify_cb(0, ctx))
835                         return 0;
836                 }
837
838         return 1;
839         }
840
841 static int internal_verify(X509_STORE_CTX *ctx)
842         {
843         int ok=0,n;
844         X509 *xs,*xi;
845         EVP_PKEY *pkey=NULL;
846         int (*cb)();
847
848         cb=ctx->verify_cb;
849
850         n=sk_X509_num(ctx->chain);
851         ctx->error_depth=n-1;
852         n--;
853         xi=sk_X509_value(ctx->chain,n);
854
855         if (ctx->check_issued(ctx, xi, xi))
856                 xs=xi;
857         else
858                 {
859                 if (n <= 0)
860                         {
861                         ctx->error=X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE;
862                         ctx->current_cert=xi;
863                         ok=cb(0,ctx);
864                         goto end;
865                         }
866                 else
867                         {
868                         n--;
869                         ctx->error_depth=n;
870                         xs=sk_X509_value(ctx->chain,n);
871                         }
872                 }
873
874 /*      ctx->error=0;  not needed */
875         while (n >= 0)
876                 {
877                 ctx->error_depth=n;
878                 if (!xs->valid)
879                         {
880                         if ((pkey=X509_get_pubkey(xi)) == NULL)
881                                 {
882                                 ctx->error=X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
883                                 ctx->current_cert=xi;
884                                 ok=(*cb)(0,ctx);
885                                 if (!ok) goto end;
886                                 }
887                         else if (X509_verify(xs,pkey) <= 0)
888                                 /* XXX  For the final trusted self-signed cert,
889                                  * this is a waste of time.  That check should
890                                  * optional so that e.g. 'openssl x509' can be
891                                  * used to detect invalid self-signatures, but
892                                  * we don't verify again and again in SSL
893                                  * handshakes and the like once the cert has
894                                  * been declared trusted. */
895                                 {
896                                 ctx->error=X509_V_ERR_CERT_SIGNATURE_FAILURE;
897                                 ctx->current_cert=xs;
898                                 ok=(*cb)(0,ctx);
899                                 if (!ok)
900                                         {
901                                         EVP_PKEY_free(pkey);
902                                         goto end;
903                                         }
904                                 }
905                         EVP_PKEY_free(pkey);
906                         pkey=NULL;
907                         }
908
909                 xs->valid = 1;
910
911                 if (!check_cert_time(ctx, xs))
912                         goto end;
913
914                 /* The last error (if any) is still in the error value */
915                 ctx->current_cert=xs;
916                 ok=(*cb)(1,ctx);
917                 if (!ok) goto end;
918
919                 n--;
920                 if (n >= 0)
921                         {
922                         xi=xs;
923                         xs=sk_X509_value(ctx->chain,n);
924                         }
925                 }
926         ok=1;
927 end:
928         return ok;
929         }
930
931 int X509_cmp_current_time(ASN1_TIME *ctm)
932 {
933         return X509_cmp_time(ctm, NULL);
934 }
935
936 int X509_cmp_time(ASN1_TIME *ctm, time_t *cmp_time)
937         {
938         char *str;
939         ASN1_TIME atm;
940         long offset;
941         char buff1[24],buff2[24],*p;
942         int i,j;
943
944         p=buff1;
945         i=ctm->length;
946         str=(char *)ctm->data;
947         if (ctm->type == V_ASN1_UTCTIME)
948                 {
949                 if ((i < 11) || (i > 17)) return 0;
950                 memcpy(p,str,10);
951                 p+=10;
952                 str+=10;
953                 }
954         else
955                 {
956                 if (i < 13) return 0;
957                 memcpy(p,str,12);
958                 p+=12;
959                 str+=12;
960                 }
961
962         if ((*str == 'Z') || (*str == '-') || (*str == '+'))
963                 { *(p++)='0'; *(p++)='0'; }
964         else
965                 { 
966                 *(p++)= *(str++);
967                 *(p++)= *(str++);
968                 /* Skip any fractional seconds... */
969                 if (*str == '.')
970                         {
971                         str++;
972                         while ((*str >= '0') && (*str <= '9')) str++;
973                         }
974                 
975                 }
976         *(p++)='Z';
977         *(p++)='\0';
978
979         if (*str == 'Z')
980                 offset=0;
981         else
982                 {
983                 if ((*str != '+') && (str[5] != '-'))
984                         return 0;
985                 offset=((str[1]-'0')*10+(str[2]-'0'))*60;
986                 offset+=(str[3]-'0')*10+(str[4]-'0');
987                 if (*str == '-')
988                         offset= -offset;
989                 }
990         atm.type=ctm->type;
991         atm.length=sizeof(buff2);
992         atm.data=(unsigned char *)buff2;
993
994         X509_time_adj(&atm,-offset*60, cmp_time);
995
996         if (ctm->type == V_ASN1_UTCTIME)
997                 {
998                 i=(buff1[0]-'0')*10+(buff1[1]-'0');
999                 if (i < 50) i+=100; /* cf. RFC 2459 */
1000                 j=(buff2[0]-'0')*10+(buff2[1]-'0');
1001                 if (j < 50) j+=100;
1002
1003                 if (i < j) return -1;
1004                 if (i > j) return 1;
1005                 }
1006         i=strcmp(buff1,buff2);
1007         if (i == 0) /* wait a second then return younger :-) */
1008                 return -1;
1009         else
1010                 return i;
1011         }
1012
1013 ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj)
1014 {
1015         return X509_time_adj(s, adj, NULL);
1016 }
1017
1018 ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *in_tm)
1019         {
1020         time_t t;
1021         int type = -1;
1022
1023         if (in_tm) t = *in_tm;
1024         else time(&t);
1025
1026         t+=adj;
1027         if (s) type = s->type;
1028         if (type == V_ASN1_UTCTIME) return ASN1_UTCTIME_set(s,t);
1029         if (type == V_ASN1_GENERALIZEDTIME) return ASN1_GENERALIZEDTIME_set(s, t);
1030         return ASN1_TIME_set(s, t);
1031         }
1032
1033 int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
1034         {
1035         EVP_PKEY *ktmp=NULL,*ktmp2;
1036         int i,j;
1037
1038         if ((pkey != NULL) && !EVP_PKEY_missing_parameters(pkey)) return 1;
1039
1040         for (i=0; i<sk_X509_num(chain); i++)
1041                 {
1042                 ktmp=X509_get_pubkey(sk_X509_value(chain,i));
1043                 if (ktmp == NULL)
1044                         {
1045                         X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY);
1046                         return 0;
1047                         }
1048                 if (!EVP_PKEY_missing_parameters(ktmp))
1049                         break;
1050                 else
1051                         {
1052                         EVP_PKEY_free(ktmp);
1053                         ktmp=NULL;
1054                         }
1055                 }
1056         if (ktmp == NULL)
1057                 {
1058                 X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN);
1059                 return 0;
1060                 }
1061
1062         /* first, populate the other certs */
1063         for (j=i-1; j >= 0; j--)
1064                 {
1065                 ktmp2=X509_get_pubkey(sk_X509_value(chain,j));
1066                 EVP_PKEY_copy_parameters(ktmp2,ktmp);
1067                 EVP_PKEY_free(ktmp2);
1068                 }
1069         
1070         if (pkey != NULL) EVP_PKEY_copy_parameters(pkey,ktmp);
1071         EVP_PKEY_free(ktmp);
1072         return 1;
1073         }
1074
1075 int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
1076              CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
1077         {
1078         /* This function is (usually) called only once, by
1079          * SSL_get_ex_data_X509_STORE_CTX_idx (ssl/ssl_cert.c). */
1080         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, argl, argp,
1081                         new_func, dup_func, free_func);
1082         }
1083
1084 int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
1085         {
1086         return CRYPTO_set_ex_data(&ctx->ex_data,idx,data);
1087         }
1088
1089 void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
1090         {
1091         return CRYPTO_get_ex_data(&ctx->ex_data,idx);
1092         }
1093
1094 int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
1095         {
1096         return ctx->error;
1097         }
1098
1099 void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
1100         {
1101         ctx->error=err;
1102         }
1103
1104 int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
1105         {
1106         return ctx->error_depth;
1107         }
1108
1109 X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
1110         {
1111         return ctx->current_cert;
1112         }
1113
1114 STACK_OF(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
1115         {
1116         return ctx->chain;
1117         }
1118
1119 STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
1120         {
1121         int i;
1122         X509 *x;
1123         STACK_OF(X509) *chain;
1124         if (!ctx->chain || !(chain = sk_X509_dup(ctx->chain))) return NULL;
1125         for (i = 0; i < sk_X509_num(chain); i++)
1126                 {
1127                 x = sk_X509_value(chain, i);
1128                 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
1129                 }
1130         return chain;
1131         }
1132
1133 void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
1134         {
1135         ctx->cert=x;
1136         }
1137
1138 void X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
1139         {
1140         ctx->untrusted=sk;
1141         }
1142
1143 void X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk)
1144         {
1145         ctx->crls=sk;
1146         }
1147
1148 int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose)
1149         {
1150         return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0);
1151         }
1152
1153 int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust)
1154         {
1155         return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust);
1156         }
1157
1158 /* This function is used to set the X509_STORE_CTX purpose and trust
1159  * values. This is intended to be used when another structure has its
1160  * own trust and purpose values which (if set) will be inherited by
1161  * the ctx. If they aren't set then we will usually have a default
1162  * purpose in mind which should then be used to set the trust value.
1163  * An example of this is SSL use: an SSL structure will have its own
1164  * purpose and trust settings which the application can set: if they
1165  * aren't set then we use the default of SSL client/server.
1166  */
1167
1168 int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
1169                                 int purpose, int trust)
1170 {
1171         int idx;
1172         /* If purpose not set use default */
1173         if (!purpose) purpose = def_purpose;
1174         /* If we have a purpose then check it is valid */
1175         if (purpose)
1176                 {
1177                 X509_PURPOSE *ptmp;
1178                 idx = X509_PURPOSE_get_by_id(purpose);
1179                 if (idx == -1)
1180                         {
1181                         X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
1182                                                 X509_R_UNKNOWN_PURPOSE_ID);
1183                         return 0;
1184                         }
1185                 ptmp = X509_PURPOSE_get0(idx);
1186                 if (ptmp->trust == X509_TRUST_DEFAULT)
1187                         {
1188                         idx = X509_PURPOSE_get_by_id(def_purpose);
1189                         if (idx == -1)
1190                                 {
1191                                 X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
1192                                                 X509_R_UNKNOWN_PURPOSE_ID);
1193                                 return 0;
1194                                 }
1195                         ptmp = X509_PURPOSE_get0(idx);
1196                         }
1197                 /* If trust not set then get from purpose default */
1198                 if (!trust) trust = ptmp->trust;
1199                 }
1200         if (trust)
1201                 {
1202                 idx = X509_TRUST_get_by_id(trust);
1203                 if (idx == -1)
1204                         {
1205                         X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
1206                                                 X509_R_UNKNOWN_TRUST_ID);
1207                         return 0;
1208                         }
1209                 }
1210
1211         if (purpose && !ctx->param->purpose) ctx->param->purpose = purpose;
1212         if (trust && !ctx->param->trust) ctx->param->trust = trust;
1213         return 1;
1214 }
1215
1216 X509_STORE_CTX *X509_STORE_CTX_new(void)
1217 {
1218         X509_STORE_CTX *ctx;
1219         ctx = (X509_STORE_CTX *)OPENSSL_malloc(sizeof(X509_STORE_CTX));
1220         if (!ctx)
1221                 {
1222                 X509err(X509_F_X509_STORE_CTX_NEW,ERR_R_MALLOC_FAILURE);
1223                 return NULL;
1224                 }
1225         memset(ctx, 0, sizeof(X509_STORE_CTX));
1226         return ctx;
1227 }
1228
1229 void X509_STORE_CTX_free(X509_STORE_CTX *ctx)
1230 {
1231         X509_STORE_CTX_cleanup(ctx);
1232         OPENSSL_free(ctx);
1233 }
1234
1235 int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
1236              STACK_OF(X509) *chain)
1237         {
1238         int ret = 1;
1239         ctx->ctx=store;
1240         ctx->current_method=0;
1241         ctx->cert=x509;
1242         ctx->untrusted=chain;
1243         ctx->crls = NULL;
1244         ctx->last_untrusted=0;
1245         ctx->other_ctx=NULL;
1246         ctx->valid=0;
1247         ctx->chain=NULL;
1248         ctx->error=0;
1249         ctx->explicit_policy=0;
1250         ctx->error_depth=0;
1251         ctx->current_cert=NULL;
1252         ctx->current_issuer=NULL;
1253         ctx->tree = NULL;
1254
1255         ctx->param = X509_VERIFY_PARAM_new();
1256
1257         if (!ctx->param)
1258                 {
1259                 X509err(X509_F_X509_STORE_CTX_INIT,ERR_R_MALLOC_FAILURE);
1260                 return 0;
1261                 }
1262
1263         /* Inherit callbacks and flags from X509_STORE if not set
1264          * use defaults.
1265          */
1266
1267
1268         if (store)
1269                 ret = X509_VERIFY_PARAM_inherit(ctx->param, store->param);
1270         else
1271                 ctx->param->flags |= X509_VP_FLAG_DEFAULT|X509_VP_FLAG_ONCE;
1272
1273         if (store)
1274                 {
1275                 ctx->verify_cb = store->verify_cb;
1276                 ctx->cleanup = store->cleanup;
1277                 }
1278         else
1279                 ctx->cleanup = 0;
1280
1281         if (ret)
1282                 ret = X509_VERIFY_PARAM_inherit(ctx->param,
1283                                         X509_VERIFY_PARAM_lookup("default"));
1284
1285         if (ret == 0)
1286                 {
1287                 X509err(X509_F_X509_STORE_CTX_INIT,ERR_R_MALLOC_FAILURE);
1288                 return 0;
1289                 }
1290
1291         if (store && store->check_issued)
1292                 ctx->check_issued = store->check_issued;
1293         else
1294                 ctx->check_issued = check_issued;
1295
1296         if (store && store->get_issuer)
1297                 ctx->get_issuer = store->get_issuer;
1298         else
1299                 ctx->get_issuer = X509_STORE_CTX_get1_issuer;
1300
1301         if (store && store->verify_cb)
1302                 ctx->verify_cb = store->verify_cb;
1303         else
1304                 ctx->verify_cb = null_callback;
1305
1306         if (store && store->verify)
1307                 ctx->verify = store->verify;
1308         else
1309                 ctx->verify = internal_verify;
1310
1311         if (store && store->check_revocation)
1312                 ctx->check_revocation = store->check_revocation;
1313         else
1314                 ctx->check_revocation = check_revocation;
1315
1316         if (store && store->get_crl)
1317                 ctx->get_crl = store->get_crl;
1318         else
1319                 ctx->get_crl = get_crl;
1320
1321         if (store && store->check_crl)
1322                 ctx->check_crl = store->check_crl;
1323         else
1324                 ctx->check_crl = check_crl;
1325
1326         if (store && store->cert_crl)
1327                 ctx->cert_crl = store->cert_crl;
1328         else
1329                 ctx->cert_crl = cert_crl;
1330
1331         ctx->check_policy = check_policy;
1332
1333
1334         /* This memset() can't make any sense anyway, so it's removed. As
1335          * X509_STORE_CTX_cleanup does a proper "free" on the ex_data, we put a
1336          * corresponding "new" here and remove this bogus initialisation. */
1337         /* memset(&(ctx->ex_data),0,sizeof(CRYPTO_EX_DATA)); */
1338         if(!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx,
1339                                 &(ctx->ex_data)))
1340                 {
1341                 OPENSSL_free(ctx);
1342                 X509err(X509_F_X509_STORE_CTX_INIT,ERR_R_MALLOC_FAILURE);
1343                 return 0;
1344                 }
1345         return 1;
1346         }
1347
1348 /* Set alternative lookup method: just a STACK of trusted certificates.
1349  * This avoids X509_STORE nastiness where it isn't needed.
1350  */
1351
1352 void X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
1353 {
1354         ctx->other_ctx = sk;
1355         ctx->get_issuer = get_issuer_sk;
1356 }
1357
1358 void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
1359         {
1360         if (ctx->cleanup) ctx->cleanup(ctx);
1361         X509_VERIFY_PARAM_free(ctx->param);
1362         if (ctx->tree)
1363                 X509_policy_tree_free(ctx->tree);
1364         if (ctx->chain != NULL)
1365                 {
1366                 sk_X509_pop_free(ctx->chain,X509_free);
1367                 ctx->chain=NULL;
1368                 }
1369         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx, &(ctx->ex_data));
1370         memset(&ctx->ex_data,0,sizeof(CRYPTO_EX_DATA));
1371         }
1372
1373 void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth)
1374         {
1375         X509_VERIFY_PARAM_set_depth(ctx->param, depth);
1376         }
1377
1378 void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags)
1379         {
1380         X509_VERIFY_PARAM_set_flags(ctx->param, flags);
1381         }
1382
1383 void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, time_t t)
1384         {
1385         X509_VERIFY_PARAM_set_time(ctx->param, t);
1386         }
1387
1388 void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
1389                                   int (*verify_cb)(int, X509_STORE_CTX *))
1390         {
1391         ctx->verify_cb=verify_cb;
1392         }
1393
1394 X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx)
1395         {
1396         return ctx->tree;
1397         }
1398
1399 int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx)
1400         {
1401         return ctx->explicit_policy;
1402         }
1403
1404 int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
1405         {
1406         const X509_VERIFY_PARAM *param;
1407         param = X509_VERIFY_PARAM_lookup(name);
1408         if (!param)
1409                 return 0;
1410         return X509_VERIFY_PARAM_inherit(ctx->param, param);
1411         }
1412
1413 X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
1414         {
1415         return ctx->param;
1416         }
1417
1418 void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
1419         {
1420         if (ctx->param)
1421                 X509_VERIFY_PARAM_free(ctx->param);
1422         ctx->param = param;
1423         }
1424
1425 IMPLEMENT_STACK_OF(X509)
1426 IMPLEMENT_ASN1_SET_OF(X509)
1427
1428 IMPLEMENT_STACK_OF(X509_NAME)
1429
1430 IMPLEMENT_STACK_OF(X509_ATTRIBUTE)
1431 IMPLEMENT_ASN1_SET_OF(X509_ATTRIBUTE)