Branch data Line data Source code
1 : : /* x509_vpm.c */
2 : : /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3 : : * project 2004.
4 : : */
5 : : /* ====================================================================
6 : : * Copyright (c) 2004 The OpenSSL Project. All rights reserved.
7 : : *
8 : : * Redistribution and use in source and binary forms, with or without
9 : : * modification, are permitted provided that the following conditions
10 : : * are met:
11 : : *
12 : : * 1. Redistributions of source code must retain the above copyright
13 : : * notice, this list of conditions and the following disclaimer.
14 : : *
15 : : * 2. Redistributions in binary form must reproduce the above copyright
16 : : * notice, this list of conditions and the following disclaimer in
17 : : * the documentation and/or other materials provided with the
18 : : * distribution.
19 : : *
20 : : * 3. All advertising materials mentioning features or use of this
21 : : * software must display the following acknowledgment:
22 : : * "This product includes software developed by the OpenSSL Project
23 : : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 : : *
25 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 : : * endorse or promote products derived from this software without
27 : : * prior written permission. For written permission, please contact
28 : : * licensing@OpenSSL.org.
29 : : *
30 : : * 5. Products derived from this software may not be called "OpenSSL"
31 : : * nor may "OpenSSL" appear in their names without prior written
32 : : * permission of the OpenSSL Project.
33 : : *
34 : : * 6. Redistributions of any form whatsoever must retain the following
35 : : * acknowledgment:
36 : : * "This product includes software developed by the OpenSSL Project
37 : : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 : : *
39 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
51 : : * ====================================================================
52 : : *
53 : : * This product includes cryptographic software written by Eric Young
54 : : * (eay@cryptsoft.com). This product includes software written by Tim
55 : : * Hudson (tjh@cryptsoft.com).
56 : : *
57 : : */
58 : :
59 : : #include <stdio.h>
60 : :
61 : : #include "cryptlib.h"
62 : : #include <openssl/crypto.h>
63 : : #include <openssl/lhash.h>
64 : : #include <openssl/buffer.h>
65 : : #include <openssl/x509.h>
66 : : #include <openssl/x509v3.h>
67 : :
68 : : #include "x509_lcl.h"
69 : :
70 : : /* X509_VERIFY_PARAM functions */
71 : :
72 : : #define SET_HOST 0
73 : : #define ADD_HOST 1
74 : :
75 : 0 : static char *str_copy(const char *s) { return OPENSSL_strdup(s); }
76 : 0 : static void str_free(char *s) { OPENSSL_free(s); }
77 : :
78 : : #define string_stack_free(sk) sk_OPENSSL_STRING_pop_free(sk, str_free)
79 : :
80 : 0 : static int int_x509_param_set_hosts(X509_VERIFY_PARAM_ID *id, int mode,
81 : : const char *name, size_t namelen)
82 : : {
83 : : char *copy;
84 : :
85 : : /*
86 : : * Refuse names with embedded NUL bytes, except perhaps as final byte.
87 : : * XXX: Do we need to push an error onto the error stack?
88 : : */
89 [ # # ]: 0 : if (namelen == 0)
90 [ # # ]: 0 : namelen = name ? strlen(name) : 0;
91 [ # # ][ # # ]: 0 : else if (name && memchr(name, '\0', namelen > 1 ? namelen-1 : namelen))
[ # # ]
92 : : return 0;
93 [ # # ][ # # ]: 0 : if (name && name[namelen-1] == '\0')
94 : 0 : --namelen;
95 : :
96 [ # # ][ # # ]: 0 : if (mode == SET_HOST && id->hosts)
97 : : {
98 : 0 : string_stack_free(id->hosts);
99 : 0 : id->hosts = NULL;
100 : : }
101 [ # # ]: 0 : if (name == NULL || namelen == 0)
102 : : return 1;
103 : :
104 : 0 : copy = BUF_strndup(name, namelen);
105 [ # # ]: 0 : if (copy == NULL)
106 : : return 0;
107 : :
108 [ # # # # ]: 0 : if (id->hosts == NULL &&
109 : 0 : (id->hosts = sk_OPENSSL_STRING_new_null()) == NULL)
110 : : {
111 : 0 : OPENSSL_free(copy);
112 : : return 0;
113 : : }
114 : :
115 [ # # ]: 0 : if (!sk_OPENSSL_STRING_push(id->hosts, copy))
116 : : {
117 : 0 : OPENSSL_free(copy);
118 [ # # ]: 0 : if (sk_OPENSSL_STRING_num(id->hosts) == 0)
119 : : {
120 : 0 : sk_OPENSSL_STRING_free(id->hosts);
121 : 0 : id->hosts = NULL;
122 : : }
123 : : return 0;
124 : : }
125 : :
126 : : return 1;
127 : : }
128 : :
129 : 16100 : static void x509_verify_param_zero(X509_VERIFY_PARAM *param)
130 : : {
131 : : X509_VERIFY_PARAM_ID *paramid;
132 [ + - ]: 16100 : if (!param)
133 : 16100 : return;
134 : 16100 : param->name = NULL;
135 : 16100 : param->purpose = 0;
136 : 16100 : param->trust = 0;
137 : : /*param->inh_flags = X509_VP_FLAG_DEFAULT;*/
138 : 16100 : param->inh_flags = 0;
139 : 16100 : param->flags = 0;
140 : 16100 : param->depth = -1;
141 [ - + ]: 16100 : if (param->policies)
142 : : {
143 : 0 : sk_ASN1_OBJECT_pop_free(param->policies, ASN1_OBJECT_free);
144 : 0 : param->policies = NULL;
145 : : }
146 : 16100 : paramid = param->id;
147 [ - + ]: 16100 : if (paramid->hosts)
148 : : {
149 : 0 : string_stack_free(paramid->hosts);
150 : 0 : paramid->hosts = NULL;
151 : : }
152 [ - + ]: 16100 : if (paramid->peername)
153 : 0 : OPENSSL_free(paramid->peername);
154 [ - + ]: 16100 : if (paramid->email)
155 : : {
156 : 0 : OPENSSL_free(paramid->email);
157 : 0 : paramid->email = NULL;
158 : 0 : paramid->emaillen = 0;
159 : : }
160 [ - + ]: 16100 : if (paramid->ip)
161 : : {
162 : 0 : OPENSSL_free(paramid->ip);
163 : 0 : paramid->ip = NULL;
164 : 0 : paramid->iplen = 0;
165 : : }
166 : :
167 : : }
168 : :
169 : 8050 : X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void)
170 : : {
171 : : X509_VERIFY_PARAM *param;
172 : : X509_VERIFY_PARAM_ID *paramid;
173 : 8050 : param = OPENSSL_malloc(sizeof(X509_VERIFY_PARAM));
174 [ + - ]: 8050 : if (!param)
175 : : return NULL;
176 : 8050 : paramid = OPENSSL_malloc(sizeof(X509_VERIFY_PARAM));
177 [ - + ]: 8050 : if (!paramid)
178 : : {
179 : 0 : OPENSSL_free(param);
180 : 0 : return NULL;
181 : : }
182 : : memset(param, 0, sizeof(X509_VERIFY_PARAM));
183 : : memset(paramid, 0, sizeof(X509_VERIFY_PARAM_ID));
184 : 8050 : param->id = paramid;
185 : 8050 : x509_verify_param_zero(param);
186 : 8050 : return param;
187 : : }
188 : :
189 : 8050 : void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param)
190 : : {
191 : 8050 : x509_verify_param_zero(param);
192 : 8050 : OPENSSL_free(param->id);
193 : 8050 : OPENSSL_free(param);
194 : 8050 : }
195 : :
196 : : /* This function determines how parameters are "inherited" from one structure
197 : : * to another. There are several different ways this can happen.
198 : : *
199 : : * 1. If a child structure needs to have its values initialized from a parent
200 : : * they are simply copied across. For example SSL_CTX copied to SSL.
201 : : * 2. If the structure should take on values only if they are currently unset.
202 : : * For example the values in an SSL structure will take appropriate value
203 : : * for SSL servers or clients but only if the application has not set new
204 : : * ones.
205 : : *
206 : : * The "inh_flags" field determines how this function behaves.
207 : : *
208 : : * Normally any values which are set in the default are not copied from the
209 : : * destination and verify flags are ORed together.
210 : : *
211 : : * If X509_VP_FLAG_DEFAULT is set then anything set in the source is copied
212 : : * to the destination. Effectively the values in "to" become default values
213 : : * which will be used only if nothing new is set in "from".
214 : : *
215 : : * If X509_VP_FLAG_OVERWRITE is set then all value are copied across whether
216 : : * they are set or not. Flags is still Ored though.
217 : : *
218 : : * If X509_VP_FLAG_RESET_FLAGS is set then the flags value is copied instead
219 : : * of ORed.
220 : : *
221 : : * If X509_VP_FLAG_LOCKED is set then no values are copied.
222 : : *
223 : : * If X509_VP_FLAG_ONCE is set then the current inh_flags setting is zeroed
224 : : * after the next call.
225 : : */
226 : :
227 : : /* Macro to test if a field should be copied from src to dest */
228 : :
229 : : #define test_x509_verify_param_copy(field, def) \
230 : : (to_overwrite || \
231 : : ((src->field != def) && (to_default || (dest->field == def))))
232 : :
233 : : /* As above but for ID fields */
234 : :
235 : : #define test_x509_verify_param_copy_id(idf, def) \
236 : : test_x509_verify_param_copy(id->idf, def)
237 : :
238 : : /* Macro to test and copy a field if necessary */
239 : :
240 : : #define x509_verify_param_copy(field, def) \
241 : : if (test_x509_verify_param_copy(field, def)) \
242 : : dest->field = src->field
243 : :
244 : :
245 : 9131 : int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *dest,
246 : : const X509_VERIFY_PARAM *src)
247 : : {
248 : : unsigned long inh_flags;
249 : : int to_default, to_overwrite;
250 : : X509_VERIFY_PARAM_ID *id;
251 [ + - ]: 9131 : if (!src)
252 : : return 1;
253 : 9131 : id = src->id;
254 : 9131 : inh_flags = dest->inh_flags | src->inh_flags;
255 : :
256 [ - + ]: 9131 : if (inh_flags & X509_VP_FLAG_ONCE)
257 : 0 : dest->inh_flags = 0;
258 : :
259 [ + - ]: 9131 : if (inh_flags & X509_VP_FLAG_LOCKED)
260 : : return 1;
261 : :
262 [ + + ]: 9131 : if (inh_flags & X509_VP_FLAG_DEFAULT)
263 : : to_default = 1;
264 : : else
265 : 7865 : to_default = 0;
266 : :
267 [ + - ]: 9131 : if (inh_flags & X509_VP_FLAG_OVERWRITE)
268 : : to_overwrite = 1;
269 : : else
270 : 9131 : to_overwrite = 0;
271 : :
272 [ + - ][ + + ]: 9131 : x509_verify_param_copy(purpose, 0);
[ + - ][ + - ]
273 [ + - ][ + + ]: 9131 : x509_verify_param_copy(trust, 0);
[ + - ][ + - ]
274 [ + - ][ + + ]: 9131 : x509_verify_param_copy(depth, -1);
[ + - ][ + - ]
275 : :
276 : : /* If overwrite or check time not set, copy across */
277 : :
278 [ + - ][ + + ]: 9131 : if (to_overwrite || !(dest->flags & X509_V_FLAG_USE_CHECK_TIME))
279 : : {
280 : 9107 : dest->check_time = src->check_time;
281 : 9107 : dest->flags &= ~X509_V_FLAG_USE_CHECK_TIME;
282 : : /* Don't need to copy flag: that is done below */
283 : : }
284 : :
285 [ - + ]: 9131 : if (inh_flags & X509_VP_FLAG_RESET_FLAGS)
286 : 0 : dest->flags = 0;
287 : :
288 : 9131 : dest->flags |= src->flags;
289 : :
290 [ + - ][ - + ]: 9131 : if (test_x509_verify_param_copy(policies, NULL))
[ # # ][ # # ]
291 : : {
292 [ # # ]: 0 : if (!X509_VERIFY_PARAM_set1_policies(dest, src->policies))
293 : : return 0;
294 : : }
295 : :
296 : : /* Copy the host flags if and only if we're copying the host list */
297 [ + - ][ - + ]: 9131 : if (test_x509_verify_param_copy_id(hosts, NULL))
[ # # ][ # # ]
298 : : {
299 [ # # ]: 0 : if (dest->id->hosts)
300 : : {
301 : 0 : string_stack_free(dest->id->hosts);
302 : 0 : dest->id->hosts = NULL;
303 : : }
304 [ # # ]: 0 : if (id->hosts)
305 : : {
306 : 0 : dest->id->hosts =
307 : 0 : sk_OPENSSL_STRING_deep_copy(id->hosts,
308 : : str_copy, str_free);
309 [ # # ]: 0 : if (dest->id->hosts == NULL)
310 : : return 0;
311 : 0 : dest->id->hostflags = id->hostflags;
312 : : }
313 : : }
314 : :
315 [ + - ][ - + ]: 9131 : if (test_x509_verify_param_copy_id(email, NULL))
[ # # ][ # # ]
316 : : {
317 [ # # ]: 0 : if (!X509_VERIFY_PARAM_set1_email(dest, id->email, id->emaillen))
318 : : return 0;
319 : : }
320 : :
321 [ + - ][ - + ]: 9131 : if (test_x509_verify_param_copy_id(ip, NULL))
[ # # ][ # # ]
322 : : {
323 [ # # ]: 0 : if (!X509_VERIFY_PARAM_set1_ip(dest, id->ip, id->iplen))
324 : : return 0;
325 : : }
326 : :
327 : : return 1;
328 : : }
329 : :
330 : 1266 : int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to,
331 : : const X509_VERIFY_PARAM *from)
332 : : {
333 : 1266 : unsigned long save_flags = to->inh_flags;
334 : : int ret;
335 : 1266 : to->inh_flags |= X509_VP_FLAG_DEFAULT;
336 : 1266 : ret = X509_VERIFY_PARAM_inherit(to, from);
337 : 1266 : to->inh_flags = save_flags;
338 : 1266 : return ret;
339 : : }
340 : :
341 : 0 : static int int_x509_param_set1(char **pdest, size_t *pdestlen,
342 : : const char *src, size_t srclen)
343 : : {
344 : : void *tmp;
345 [ # # ]: 0 : if (src)
346 : : {
347 [ # # ]: 0 : if (srclen == 0)
348 : : {
349 : 0 : tmp = BUF_strdup(src);
350 : 0 : srclen = strlen(src);
351 : : }
352 : : else
353 : 0 : tmp = BUF_memdup(src, srclen);
354 [ # # ]: 0 : if (!tmp)
355 : : return 0;
356 : : }
357 : : else
358 : : {
359 : : tmp = NULL;
360 : : srclen = 0;
361 : : }
362 [ # # ]: 0 : if (*pdest)
363 : 0 : OPENSSL_free(*pdest);
364 : 0 : *pdest = tmp;
365 [ # # ]: 0 : if (pdestlen)
366 : 0 : *pdestlen = srclen;
367 : : return 1;
368 : : }
369 : :
370 : 0 : int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name)
371 : : {
372 [ # # ]: 0 : if (param->name)
373 : 0 : OPENSSL_free(param->name);
374 : 0 : param->name = BUF_strdup(name);
375 [ # # ]: 0 : if (param->name)
376 : : return 1;
377 : 0 : return 0;
378 : : }
379 : :
380 : 1542 : int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags)
381 : : {
382 : 1542 : param->flags |= flags;
383 [ - + ]: 1542 : if (flags & X509_V_FLAG_POLICY_MASK)
384 : 0 : param->flags |= X509_V_FLAG_POLICY_CHECK;
385 : 1542 : return 1;
386 : : }
387 : :
388 : 0 : int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags)
389 : : {
390 : 0 : param->flags &= ~flags;
391 : 0 : return 1;
392 : : }
393 : :
394 : 0 : unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param)
395 : : {
396 : 0 : return param->flags;
397 : : }
398 : :
399 : 0 : int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose)
400 : : {
401 : 0 : return X509_PURPOSE_set(¶m->purpose, purpose);
402 : : }
403 : :
404 : 0 : int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust)
405 : : {
406 : 0 : return X509_TRUST_set(¶m->trust, trust);
407 : : }
408 : :
409 : 0 : void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth)
410 : : {
411 : 0 : param->depth = depth;
412 : 0 : }
413 : :
414 : 54 : void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t)
415 : : {
416 : 54 : param->check_time = t;
417 : 54 : param->flags |= X509_V_FLAG_USE_CHECK_TIME;
418 : 54 : }
419 : :
420 : 0 : int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy)
421 : : {
422 [ # # ]: 0 : if (!param->policies)
423 : : {
424 : 0 : param->policies = sk_ASN1_OBJECT_new_null();
425 [ # # ]: 0 : if (!param->policies)
426 : : return 0;
427 : : }
428 [ # # ]: 0 : if (!sk_ASN1_OBJECT_push(param->policies, policy))
429 : : return 0;
430 : 0 : return 1;
431 : : }
432 : :
433 : 0 : int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
434 : : STACK_OF(ASN1_OBJECT) *policies)
435 : : {
436 : : int i;
437 : : ASN1_OBJECT *oid, *doid;
438 [ # # ]: 0 : if (!param)
439 : : return 0;
440 [ # # ]: 0 : if (param->policies)
441 : 0 : sk_ASN1_OBJECT_pop_free(param->policies, ASN1_OBJECT_free);
442 : :
443 [ # # ]: 0 : if (!policies)
444 : : {
445 : 0 : param->policies = NULL;
446 : 0 : return 1;
447 : : }
448 : :
449 : 0 : param->policies = sk_ASN1_OBJECT_new_null();
450 [ # # ]: 0 : if (!param->policies)
451 : : return 0;
452 : :
453 [ # # ]: 0 : for (i = 0; i < sk_ASN1_OBJECT_num(policies); i++)
454 : : {
455 : 0 : oid = sk_ASN1_OBJECT_value(policies, i);
456 : 0 : doid = OBJ_dup(oid);
457 [ # # ]: 0 : if (!doid)
458 : : return 0;
459 [ # # ]: 0 : if (!sk_ASN1_OBJECT_push(param->policies, doid))
460 : : {
461 : 0 : ASN1_OBJECT_free(doid);
462 : 0 : return 0;
463 : : }
464 : : }
465 : 0 : param->flags |= X509_V_FLAG_POLICY_CHECK;
466 : 0 : return 1;
467 : : }
468 : :
469 : 0 : int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
470 : : const char *name, size_t namelen)
471 : : {
472 : 0 : return int_x509_param_set_hosts(param->id, SET_HOST, name, namelen);
473 : : }
474 : :
475 : 0 : int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
476 : : const char *name, size_t namelen)
477 : : {
478 : 0 : return int_x509_param_set_hosts(param->id, ADD_HOST, name, namelen);
479 : : }
480 : :
481 : 0 : void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,
482 : : unsigned int flags)
483 : : {
484 : 0 : param->id->hostflags = flags;
485 : 0 : }
486 : :
487 : 0 : char *X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *param)
488 : : {
489 : 0 : return param->id->peername;
490 : : }
491 : :
492 : 0 : int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,
493 : : const char *email, size_t emaillen)
494 : : {
495 : 0 : return int_x509_param_set1(¶m->id->email, ¶m->id->emaillen,
496 : : email, emaillen);
497 : : }
498 : :
499 : 0 : int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,
500 : : const unsigned char *ip, size_t iplen)
501 : : {
502 [ # # ][ # # ]: 0 : if (iplen != 0 && iplen != 4 && iplen != 16)
503 : : return 0;
504 : 0 : return int_x509_param_set1((char **)¶m->id->ip, ¶m->id->iplen,
505 : : (char *)ip, iplen);
506 : : }
507 : :
508 : 0 : int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc)
509 : : {
510 : : unsigned char ipout[16];
511 : : size_t iplen;
512 : :
513 : 0 : iplen = (size_t) a2i_ipadd(ipout, ipasc);
514 [ # # ]: 0 : if (iplen == 0)
515 : : return 0;
516 : 0 : return X509_VERIFY_PARAM_set1_ip(param, ipout, iplen);
517 : : }
518 : :
519 : 0 : int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param)
520 : : {
521 : 0 : return param->depth;
522 : : }
523 : :
524 : 0 : const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param)
525 : : {
526 : 0 : return param->name;
527 : : }
528 : :
529 : : static X509_VERIFY_PARAM_ID _empty_id = {NULL, 0U, NULL, NULL, 0, NULL, 0};
530 : :
531 : : #define vpm_empty_id (X509_VERIFY_PARAM_ID *)&_empty_id
532 : :
533 : :
534 : : /* Default verify parameters: these are used for various
535 : : * applications and can be overridden by the user specified table.
536 : : * NB: the 'name' field *must* be in alphabetical order because it
537 : : * will be searched using OBJ_search.
538 : : */
539 : :
540 : : static const X509_VERIFY_PARAM default_table[] = {
541 : : {
542 : : "default", /* X509 default parameters */
543 : : 0, /* Check time */
544 : : 0, /* internal flags */
545 : : 0, /* flags */
546 : : 0, /* purpose */
547 : : 0, /* trust */
548 : : 100, /* depth */
549 : : NULL, /* policies */
550 : : vpm_empty_id
551 : : },
552 : : {
553 : : "pkcs7", /* S/MIME sign parameters */
554 : : 0, /* Check time */
555 : : 0, /* internal flags */
556 : : 0, /* flags */
557 : : X509_PURPOSE_SMIME_SIGN, /* purpose */
558 : : X509_TRUST_EMAIL, /* trust */
559 : : -1, /* depth */
560 : : NULL, /* policies */
561 : : vpm_empty_id
562 : : },
563 : : {
564 : : "smime_sign", /* S/MIME sign parameters */
565 : : 0, /* Check time */
566 : : 0, /* internal flags */
567 : : 0, /* flags */
568 : : X509_PURPOSE_SMIME_SIGN, /* purpose */
569 : : X509_TRUST_EMAIL, /* trust */
570 : : -1, /* depth */
571 : : NULL, /* policies */
572 : : vpm_empty_id
573 : : },
574 : : {
575 : : "ssl_client", /* SSL/TLS client parameters */
576 : : 0, /* Check time */
577 : : 0, /* internal flags */
578 : : 0, /* flags */
579 : : X509_PURPOSE_SSL_CLIENT, /* purpose */
580 : : X509_TRUST_SSL_CLIENT, /* trust */
581 : : -1, /* depth */
582 : : NULL, /* policies */
583 : : vpm_empty_id
584 : : },
585 : : {
586 : : "ssl_server", /* SSL/TLS server parameters */
587 : : 0, /* Check time */
588 : : 0, /* internal flags */
589 : : 0, /* flags */
590 : : X509_PURPOSE_SSL_SERVER, /* purpose */
591 : : X509_TRUST_SSL_SERVER, /* trust */
592 : : -1, /* depth */
593 : : NULL, /* policies */
594 : : vpm_empty_id
595 : : }};
596 : :
597 : : static STACK_OF(X509_VERIFY_PARAM) *param_table = NULL;
598 : :
599 : 9792 : static int table_cmp(const X509_VERIFY_PARAM *a, const X509_VERIFY_PARAM *b)
600 : :
601 : : {
602 : 9792 : return strcmp(a->name, b->name);
603 : : }
604 : :
605 : : DECLARE_OBJ_BSEARCH_CMP_FN(X509_VERIFY_PARAM, X509_VERIFY_PARAM,
606 : : table);
607 : 26938 : IMPLEMENT_OBJ_BSEARCH_CMP_FN(X509_VERIFY_PARAM, X509_VERIFY_PARAM,
608 : : table);
609 : :
610 : 0 : static int param_cmp(const X509_VERIFY_PARAM * const *a,
611 : : const X509_VERIFY_PARAM * const *b)
612 : : {
613 : 0 : return strcmp((*a)->name, (*b)->name);
614 : : }
615 : :
616 : 0 : int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param)
617 : : {
618 : : int idx;
619 : : X509_VERIFY_PARAM *ptmp;
620 [ # # ]: 0 : if (!param_table)
621 : : {
622 : 0 : param_table = sk_X509_VERIFY_PARAM_new(param_cmp);
623 [ # # ]: 0 : if (!param_table)
624 : : return 0;
625 : : }
626 : : else
627 : : {
628 : 0 : idx = sk_X509_VERIFY_PARAM_find(param_table, param);
629 [ # # ]: 0 : if (idx != -1)
630 : : {
631 : 0 : ptmp = sk_X509_VERIFY_PARAM_value(param_table, idx);
632 : 0 : X509_VERIFY_PARAM_free(ptmp);
633 : 0 : (void)sk_X509_VERIFY_PARAM_delete(param_table, idx);
634 : : }
635 : : }
636 [ # # ]: 0 : if (!sk_X509_VERIFY_PARAM_push(param_table, param))
637 : : return 0;
638 : 0 : return 1;
639 : : }
640 : :
641 : 0 : int X509_VERIFY_PARAM_get_count(void)
642 : : {
643 : 0 : int num = sizeof(default_table)/sizeof(X509_VERIFY_PARAM);
644 [ # # ]: 0 : if (param_table)
645 : 0 : num += sk_X509_VERIFY_PARAM_num(param_table);
646 : 0 : return num;
647 : : }
648 : :
649 : 0 : const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id)
650 : : {
651 : 0 : int num = sizeof(default_table)/sizeof(X509_VERIFY_PARAM);
652 [ # # ]: 0 : if (id < num)
653 : 0 : return default_table + id;
654 : 0 : return sk_X509_VERIFY_PARAM_value(param_table, id - num);
655 : : }
656 : :
657 : 3677 : const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name)
658 : : {
659 : : int idx;
660 : : X509_VERIFY_PARAM pm;
661 : :
662 : 3677 : pm.name = (char *)name;
663 [ - + ]: 3677 : if (param_table)
664 : : {
665 : 0 : idx = sk_X509_VERIFY_PARAM_find(param_table, &pm);
666 [ # # ]: 0 : if (idx != -1)
667 : 0 : return sk_X509_VERIFY_PARAM_value(param_table, idx);
668 : : }
669 : 3677 : return OBJ_bsearch_table(&pm, default_table,
670 : : sizeof(default_table)/sizeof(X509_VERIFY_PARAM));
671 : : }
672 : :
673 : 0 : void X509_VERIFY_PARAM_table_cleanup(void)
674 : : {
675 [ # # ]: 0 : if (param_table)
676 : 0 : sk_X509_VERIFY_PARAM_pop_free(param_table,
677 : : X509_VERIFY_PARAM_free);
678 : 0 : param_table = NULL;
679 : 0 : }
|
