35a8e351c0274c70183d9df29909f219db441199
[openssl.git] / crypto / x509 / x509_lu.c
1 /* crypto/x509/x509_lu.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 "cryptlib.h"
61 #include <openssl/lhash.h>
62 #include <openssl/x509.h>
63 #include <openssl/x509v3.h>
64
65 X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
66         {
67         X509_LOOKUP *ret;
68
69         ret=(X509_LOOKUP *)OPENSSL_malloc(sizeof(X509_LOOKUP));
70         if (ret == NULL) return NULL;
71
72         ret->init=0;
73         ret->skip=0;
74         ret->method=method;
75         ret->method_data=NULL;
76         ret->store_ctx=NULL;
77         if ((method->new_item != NULL) && !method->new_item(ret))
78                 {
79                 OPENSSL_free(ret);
80                 return NULL;
81                 }
82         return ret;
83         }
84
85 void X509_LOOKUP_free(X509_LOOKUP *ctx)
86         {
87         if (ctx == NULL) return;
88         if (    (ctx->method != NULL) &&
89                 (ctx->method->free != NULL))
90                 ctx->method->free(ctx);
91         OPENSSL_free(ctx);
92         }
93
94 int X509_LOOKUP_init(X509_LOOKUP *ctx)
95         {
96         if (ctx->method == NULL) return 0;
97         if (ctx->method->init != NULL)
98                 return ctx->method->init(ctx);
99         else
100                 return 1;
101         }
102
103 int X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
104         {
105         if (ctx->method == NULL) return 0;
106         if (ctx->method->shutdown != NULL)
107                 return ctx->method->shutdown(ctx);
108         else
109                 return 1;
110         }
111
112 int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
113              char **ret)
114         {
115         if (ctx->method == NULL) return -1;
116         if (ctx->method->ctrl != NULL)
117                 return ctx->method->ctrl(ctx,cmd,argc,argl,ret);
118         else
119                 return 1;
120         }
121
122 int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name,
123              X509_OBJECT *ret)
124         {
125         if ((ctx->method == NULL) || (ctx->method->get_by_subject == NULL))
126                 return X509_LU_FAIL;
127         if (ctx->skip) return 0;
128         return ctx->method->get_by_subject(ctx,type,name,ret);
129         }
130
131 int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, int type, X509_NAME *name,
132              ASN1_INTEGER *serial, X509_OBJECT *ret)
133         {
134         if ((ctx->method == NULL) ||
135                 (ctx->method->get_by_issuer_serial == NULL))
136                 return X509_LU_FAIL;
137         return ctx->method->get_by_issuer_serial(ctx,type,name,serial,ret);
138         }
139
140 int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, int type,
141              unsigned char *bytes, int len, X509_OBJECT *ret)
142         {
143         if ((ctx->method == NULL) || (ctx->method->get_by_fingerprint == NULL))
144                 return X509_LU_FAIL;
145         return ctx->method->get_by_fingerprint(ctx,type,bytes,len,ret);
146         }
147
148 int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, int type, char *str, int len,
149              X509_OBJECT *ret)
150         {
151         if ((ctx->method == NULL) || (ctx->method->get_by_alias == NULL))
152                 return X509_LU_FAIL;
153         return ctx->method->get_by_alias(ctx,type,str,len,ret);
154         }
155
156   
157 static int x509_object_cmp(const X509_OBJECT * const *a, const X509_OBJECT * const *b)
158         {
159         int ret;
160
161         ret=((*a)->type - (*b)->type);
162         if (ret) return ret;
163         switch ((*a)->type)
164                 {
165         case X509_LU_X509:
166                 ret=X509_subject_name_cmp((*a)->data.x509,(*b)->data.x509);
167                 break;
168         case X509_LU_CRL:
169                 ret=X509_CRL_cmp((*a)->data.crl,(*b)->data.crl);
170                 break;
171         default:
172                 /* abort(); */
173                 return 0;
174                 }
175         return ret;
176         }
177
178 X509_STORE *X509_STORE_new(void)
179         {
180         X509_STORE *ret;
181
182         if ((ret=(X509_STORE *)OPENSSL_malloc(sizeof(X509_STORE))) == NULL)
183                 return NULL;
184         ret->objs = sk_X509_OBJECT_new(x509_object_cmp);
185         ret->cache=1;
186         ret->get_cert_methods=sk_X509_LOOKUP_new_null();
187         ret->verify=0;
188         ret->verify_cb=0;
189
190         if ((ret->param = X509_VERIFY_PARAM_new()) == NULL)
191                 return NULL;
192
193         ret->get_issuer = 0;
194         ret->check_issued = 0;
195         ret->check_revocation = 0;
196         ret->get_crl = 0;
197         ret->check_crl = 0;
198         ret->cert_crl = 0;
199         ret->cleanup = 0;
200
201         CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data);
202         ret->references=1;
203         return ret;
204         }
205
206 static void cleanup(X509_OBJECT *a)
207         {
208         if (a->type == X509_LU_X509)
209                 {
210                 X509_free(a->data.x509);
211                 }
212         else if (a->type == X509_LU_CRL)
213                 {
214                 X509_CRL_free(a->data.crl);
215                 }
216         else
217                 {
218                 /* abort(); */
219                 }
220
221         OPENSSL_free(a);
222         }
223
224 void X509_STORE_free(X509_STORE *vfy)
225         {
226         int i;
227         STACK_OF(X509_LOOKUP) *sk;
228         X509_LOOKUP *lu;
229
230         if (vfy == NULL)
231             return;
232
233         sk=vfy->get_cert_methods;
234         for (i=0; i<sk_X509_LOOKUP_num(sk); i++)
235                 {
236                 lu=sk_X509_LOOKUP_value(sk,i);
237                 X509_LOOKUP_shutdown(lu);
238                 X509_LOOKUP_free(lu);
239                 }
240         sk_X509_LOOKUP_free(sk);
241         sk_X509_OBJECT_pop_free(vfy->objs, cleanup);
242
243         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE, vfy, &vfy->ex_data);
244         if (vfy->param)
245                 X509_VERIFY_PARAM_free(vfy->param);
246         OPENSSL_free(vfy);
247         }
248
249 X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)
250         {
251         int i;
252         STACK_OF(X509_LOOKUP) *sk;
253         X509_LOOKUP *lu;
254
255         sk=v->get_cert_methods;
256         for (i=0; i<sk_X509_LOOKUP_num(sk); i++)
257                 {
258                 lu=sk_X509_LOOKUP_value(sk,i);
259                 if (m == lu->method)
260                         {
261                         return lu;
262                         }
263                 }
264         /* a new one */
265         lu=X509_LOOKUP_new(m);
266         if (lu == NULL)
267                 return NULL;
268         else
269                 {
270                 lu->store_ctx=v;
271                 if (sk_X509_LOOKUP_push(v->get_cert_methods,lu))
272                         return lu;
273                 else
274                         {
275                         X509_LOOKUP_free(lu);
276                         return NULL;
277                         }
278                 }
279         }
280
281 int X509_STORE_get_by_subject(X509_STORE_CTX *vs, int type, X509_NAME *name,
282              X509_OBJECT *ret)
283         {
284         X509_STORE *ctx=vs->ctx;
285         X509_LOOKUP *lu;
286         X509_OBJECT stmp,*tmp;
287         int i,j;
288
289         tmp=X509_OBJECT_retrieve_by_subject(ctx->objs,type,name);
290
291         if (tmp == NULL)
292                 {
293                 for (i=vs->current_method; i<sk_X509_LOOKUP_num(ctx->get_cert_methods); i++)
294                         {
295                         lu=sk_X509_LOOKUP_value(ctx->get_cert_methods,i);
296                         j=X509_LOOKUP_by_subject(lu,type,name,&stmp);
297                         if (j < 0)
298                                 {
299                                 vs->current_method=j;
300                                 return j;
301                                 }
302                         else if (j)
303                                 {
304                                 tmp= &stmp;
305                                 break;
306                                 }
307                         }
308                 vs->current_method=0;
309                 if (tmp == NULL)
310                         return 0;
311                 }
312
313 /*      if (ret->data.ptr != NULL)
314                 X509_OBJECT_free_contents(ret); */
315
316         ret->type=tmp->type;
317         ret->data.ptr=tmp->data.ptr;
318
319         X509_OBJECT_up_ref_count(ret);
320
321         return 1;
322         }
323
324 int X509_STORE_add_cert(X509_STORE *ctx, X509 *x)
325         {
326         X509_OBJECT *obj;
327         int ret=1;
328
329         if (x == NULL) return 0;
330         obj=(X509_OBJECT *)OPENSSL_malloc(sizeof(X509_OBJECT));
331         if (obj == NULL)
332                 {
333                 X509err(X509_F_X509_STORE_ADD_CERT,ERR_R_MALLOC_FAILURE);
334                 return 0;
335                 }
336         obj->type=X509_LU_X509;
337         obj->data.x509=x;
338
339         CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
340
341         X509_OBJECT_up_ref_count(obj);
342
343
344         if (X509_OBJECT_retrieve_match(ctx->objs, obj))
345                 {
346                 X509_OBJECT_free_contents(obj);
347                 OPENSSL_free(obj);
348                 X509err(X509_F_X509_STORE_ADD_CERT,X509_R_CERT_ALREADY_IN_HASH_TABLE);
349                 ret=0;
350                 } 
351         else sk_X509_OBJECT_push(ctx->objs, obj);
352
353         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
354
355         return ret;
356         }
357
358 int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x)
359         {
360         X509_OBJECT *obj;
361         int ret=1;
362
363         if (x == NULL) return 0;
364         obj=(X509_OBJECT *)OPENSSL_malloc(sizeof(X509_OBJECT));
365         if (obj == NULL)
366                 {
367                 X509err(X509_F_X509_STORE_ADD_CRL,ERR_R_MALLOC_FAILURE);
368                 return 0;
369                 }
370         obj->type=X509_LU_CRL;
371         obj->data.crl=x;
372
373         CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
374
375         X509_OBJECT_up_ref_count(obj);
376
377         if (X509_OBJECT_retrieve_match(ctx->objs, obj))
378                 {
379                 X509_OBJECT_free_contents(obj);
380                 OPENSSL_free(obj);
381                 X509err(X509_F_X509_STORE_ADD_CRL,X509_R_CERT_ALREADY_IN_HASH_TABLE);
382                 ret=0;
383                 }
384         else sk_X509_OBJECT_push(ctx->objs, obj);
385
386         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
387
388         return ret;
389         }
390
391 void X509_OBJECT_up_ref_count(X509_OBJECT *a)
392         {
393         switch (a->type)
394                 {
395         case X509_LU_X509:
396                 CRYPTO_add(&a->data.x509->references,1,CRYPTO_LOCK_X509);
397                 break;
398         case X509_LU_CRL:
399                 CRYPTO_add(&a->data.crl->references,1,CRYPTO_LOCK_X509_CRL);
400                 break;
401                 }
402         }
403
404 void X509_OBJECT_free_contents(X509_OBJECT *a)
405         {
406         switch (a->type)
407                 {
408         case X509_LU_X509:
409                 X509_free(a->data.x509);
410                 break;
411         case X509_LU_CRL:
412                 X509_CRL_free(a->data.crl);
413                 break;
414                 }
415         }
416
417 static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,
418              X509_NAME *name, int *pnmatch)
419         {
420         X509_OBJECT stmp;
421         X509 x509_s;
422         X509_CINF cinf_s;
423         X509_CRL crl_s;
424         X509_CRL_INFO crl_info_s;
425         int idx;
426
427         stmp.type=type;
428         switch (type)
429                 {
430         case X509_LU_X509:
431                 stmp.data.x509= &x509_s;
432                 x509_s.cert_info= &cinf_s;
433                 cinf_s.subject=name;
434                 break;
435         case X509_LU_CRL:
436                 stmp.data.crl= &crl_s;
437                 crl_s.crl= &crl_info_s;
438                 crl_info_s.issuer=name;
439                 break;
440         default:
441                 /* abort(); */
442                 return -1;
443                 }
444
445         idx = sk_X509_OBJECT_find(h,&stmp);
446         if (idx >= 0 && pnmatch)
447                 {
448                 int tidx;
449                 const X509_OBJECT *tobj, *pstmp;
450                 *pnmatch = 1;
451                 pstmp = &stmp;
452                 for (tidx = idx + 1; tidx < sk_X509_OBJECT_num(h); tidx++)
453                         {
454                         tobj = sk_X509_OBJECT_value(h, tidx);
455                         if (!x509_object_cmp(&tobj, &pstmp))
456                                 break;
457                         *pnmatch++;
458                         }
459                 }
460         return idx;
461         }
462
463
464 int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, int type,
465              X509_NAME *name)
466         {
467         return x509_object_idx_cnt(h, type, name, NULL);
468         }
469
470 X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, int type,
471              X509_NAME *name)
472 {
473         int idx;
474         idx = X509_OBJECT_idx_by_subject(h, type, name);
475         if (idx==-1) return NULL;
476         return sk_X509_OBJECT_value(h, idx);
477 }
478
479 STACK_OF(X509)* X509_STORE_get_certs(X509_STORE *st, X509_NAME *nm)
480         {
481         int i, idx, cnt;
482         STACK_OF(X509) *sk;
483         X509 *x;
484         X509_OBJECT *obj;
485         sk = sk_X509_new_null();
486         CRYPTO_r_lock(CRYPTO_LOCK_X509_STORE);
487         idx = x509_object_idx_cnt(st->objs, X509_LU_X509, nm, &cnt);
488         if (idx < 0)
489                 {
490                 CRYPTO_r_unlock(CRYPTO_LOCK_X509_STORE);
491                 sk_X509_free(sk);
492                 return NULL;
493                 }
494         for (i = 0; i < cnt; i++, idx++)
495                 {
496                 obj = sk_X509_OBJECT_value(st->objs, i);
497                 x = obj->data.x509;
498                 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
499                 if (!sk_X509_push(sk, x))
500                         {
501                         CRYPTO_r_unlock(CRYPTO_LOCK_X509_STORE);
502                         X509_free(x);
503                         sk_X509_pop_free(sk, X509_free);
504                         return NULL;
505                         }
506                 }
507         CRYPTO_r_unlock(CRYPTO_LOCK_X509_STORE);
508         return sk;
509
510         }
511
512 STACK_OF(X509_CRL)* X509_STORE_get_crls(X509_STORE *st, X509_NAME *nm)
513         {
514         int i, idx, cnt;
515         STACK_OF(X509_CRL) *sk;
516         X509_CRL *x;
517         X509_OBJECT *obj;
518         sk = sk_X509_CRL_new_null();
519         CRYPTO_r_lock(CRYPTO_LOCK_X509_STORE);
520         idx = x509_object_idx_cnt(st->objs, X509_LU_CRL, nm, &cnt);
521         if (idx < 0)
522                 {
523                 CRYPTO_r_unlock(CRYPTO_LOCK_X509_STORE);
524                 sk_X509_CRL_free(sk);
525                 return NULL;
526                 }
527         for (i = 0; i < cnt; i++, idx++)
528                 {
529                 obj = sk_X509_OBJECT_value(st->objs, i);
530                 x = obj->data.crl;
531                 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL);
532                 if (!sk_X509_CRL_push(sk, x))
533                         {
534                         CRYPTO_r_unlock(CRYPTO_LOCK_X509_STORE);
535                         X509_CRL_free(x);
536                         sk_X509_CRL_pop_free(sk, X509_CRL_free);
537                         return NULL;
538                         }
539                 }
540         CRYPTO_r_unlock(CRYPTO_LOCK_X509_STORE);
541         return sk;
542
543         }
544
545 X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x)
546 {
547         int idx, i;
548         X509_OBJECT *obj;
549         idx = sk_X509_OBJECT_find(h, x);
550         if (idx == -1) return NULL;
551         if ((x->type != X509_LU_X509) && (x->type != X509_LU_CRL))
552                 return sk_X509_OBJECT_value(h, idx);
553         for (i = idx; i < sk_X509_OBJECT_num(h); i++)
554                 {
555                 obj = sk_X509_OBJECT_value(h, i);
556                 if (x509_object_cmp((const X509_OBJECT **)&obj, (const X509_OBJECT **)&x))
557                         return NULL;
558                 if (x->type == X509_LU_X509)
559                         {
560                         if (!X509_cmp(obj->data.x509, x->data.x509))
561                                 return obj;
562                         }
563                 else if (x->type == X509_LU_CRL)
564                         {
565                         if (!X509_CRL_match(obj->data.crl, x->data.crl))
566                                 return obj;
567                         }
568                 else
569                         return obj;
570                 }
571         return NULL;
572 }
573
574
575 /* Try to get issuer certificate from store. Due to limitations
576  * of the API this can only retrieve a single certificate matching
577  * a given subject name. However it will fill the cache with all
578  * matching certificates, so we can examine the cache for all 
579  * matches.
580  *
581  * Return values are:
582  *  1 lookup successful.
583  *  0 certificate not found.
584  * -1 some other error.
585  */
586
587
588 int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x)
589 {
590         X509_NAME *xn;
591         X509_OBJECT obj, *pobj;
592         int i, ok, idx;
593         xn=X509_get_issuer_name(x);
594         ok=X509_STORE_get_by_subject(ctx,X509_LU_X509,xn,&obj);
595         if (ok != X509_LU_X509)
596                 {
597                 if (ok == X509_LU_RETRY)
598                         {
599                         X509_OBJECT_free_contents(&obj);
600                         X509err(X509_F_X509_STORE_CTX_GET1_ISSUER,X509_R_SHOULD_RETRY);
601                         return -1;
602                         }
603                 else if (ok != X509_LU_FAIL)
604                         {
605                         X509_OBJECT_free_contents(&obj);
606                         /* not good :-(, break anyway */
607                         return -1;
608                         }
609                 return 0;
610                 }
611         /* If certificate matches all OK */
612         if (ctx->check_issued(ctx, x, obj.data.x509))
613                 {
614                 *issuer = obj.data.x509;
615                 return 1;
616                 }
617         X509_OBJECT_free_contents(&obj);
618         /* Else find index of first matching cert */
619         idx = X509_OBJECT_idx_by_subject(ctx->ctx->objs, X509_LU_X509, xn);
620         /* This shouldn't normally happen since we already have one match */
621         if (idx == -1) return 0;
622
623         /* Look through all matching certificates for a suitable issuer */
624         for (i = idx; i < sk_X509_OBJECT_num(ctx->ctx->objs); i++)
625                 {
626                 pobj = sk_X509_OBJECT_value(ctx->ctx->objs, i);
627                 /* See if we've ran out of matches */
628                 if (pobj->type != X509_LU_X509) return 0;
629                 if (X509_NAME_cmp(xn, X509_get_subject_name(pobj->data.x509))) return 0;
630                 if (ctx->check_issued(ctx, x, pobj->data.x509))
631                         {
632                         *issuer = pobj->data.x509;
633                         X509_OBJECT_up_ref_count(pobj);
634                         return 1;
635                         }
636                 }
637         return 0;
638 }
639
640 int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags)
641         {
642         return X509_VERIFY_PARAM_set_flags(ctx->param, flags);
643         }
644
645 int X509_STORE_set_depth(X509_STORE *ctx, int depth)
646         {
647         X509_VERIFY_PARAM_set_depth(ctx->param, depth);
648         return 1;
649         }
650
651 int X509_STORE_set_purpose(X509_STORE *ctx, int purpose)
652         {
653         return X509_VERIFY_PARAM_set_purpose(ctx->param, purpose);
654         }
655
656 int X509_STORE_set_trust(X509_STORE *ctx, int trust)
657         {
658         return X509_VERIFY_PARAM_set_trust(ctx->param, trust);
659         }
660
661 int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *param)
662         {
663         return X509_VERIFY_PARAM_set1(ctx->param, param);
664         }
665
666 IMPLEMENT_STACK_OF(X509_LOOKUP)
667 IMPLEMENT_STACK_OF(X509_OBJECT)