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