Branch data Line data Source code
1 : : /* crypto/objects/obj_dat.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 <ctype.h>
61 : : #include <limits.h>
62 : : #include "cryptlib.h"
63 : : #include <openssl/lhash.h>
64 : : #include <openssl/asn1.h>
65 : : #include <openssl/objects.h>
66 : : #include <openssl/bn.h>
67 : :
68 : : /* obj_dat.h is generated from objects.h by obj_dat.pl */
69 : : #ifndef OPENSSL_NO_OBJECT
70 : : #include "obj_dat.h"
71 : : #else
72 : : /* You will have to load all the objects needed manually in the application */
73 : : #define NUM_NID 0
74 : : #define NUM_SN 0
75 : : #define NUM_LN 0
76 : : #define NUM_OBJ 0
77 : : static const unsigned char lvalues[1];
78 : : static const ASN1_OBJECT nid_objs[1];
79 : : static const unsigned int sn_objs[1];
80 : : static const unsigned int ln_objs[1];
81 : : static const unsigned int obj_objs[1];
82 : : #endif
83 : :
84 : : DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
85 : : DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
86 : : DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
87 : :
88 : : #define ADDED_DATA 0
89 : : #define ADDED_SNAME 1
90 : : #define ADDED_LNAME 2
91 : : #define ADDED_NID 3
92 : :
93 : : typedef struct added_obj_st
94 : : {
95 : : int type;
96 : : ASN1_OBJECT *obj;
97 : : } ADDED_OBJ;
98 : : DECLARE_LHASH_OF(ADDED_OBJ);
99 : :
100 : : static int new_nid=NUM_NID;
101 : : static LHASH_OF(ADDED_OBJ) *added=NULL;
102 : :
103 : 1932 : static int sn_cmp(const ASN1_OBJECT * const *a, const unsigned int *b)
104 : 1932 : { return(strcmp((*a)->sn,nid_objs[*b].sn)); }
105 : :
106 : 4280 : IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
107 : :
108 : 549 : static int ln_cmp(const ASN1_OBJECT * const *a, const unsigned int *b)
109 : 549 : { return(strcmp((*a)->ln,nid_objs[*b].ln)); }
110 : :
111 : 1214 : IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
112 : :
113 : 2548 : static unsigned long added_obj_hash(const ADDED_OBJ *ca)
114 : : {
115 : : const ASN1_OBJECT *a;
116 : : int i;
117 : 2548 : unsigned long ret=0;
118 : : unsigned char *p;
119 : :
120 : 2548 : a=ca->obj;
121 [ + + + + : 2548 : switch (ca->type)
- ]
122 : : {
123 : : case ADDED_DATA:
124 : 1822 : ret=a->length<<20L;
125 : 1822 : p=(unsigned char *)a->data;
126 [ + + ]: 10533 : for (i=0; i<a->length; i++)
127 : 8711 : ret^=p[i]<<((i*3)%24);
128 : : break;
129 : : case ADDED_SNAME:
130 : 319 : ret=lh_strhash(a->sn);
131 : 319 : break;
132 : : case ADDED_LNAME:
133 : 205 : ret=lh_strhash(a->ln);
134 : 205 : break;
135 : : case ADDED_NID:
136 : 202 : ret=a->nid;
137 : 202 : break;
138 : : default:
139 : : /* abort(); */
140 : : return 0;
141 : : }
142 : 2548 : ret&=0x3fffffffL;
143 : 2548 : ret|=((unsigned long)ca->type)<<30L;
144 : 2548 : return(ret);
145 : : }
146 : 5096 : static IMPLEMENT_LHASH_HASH_FN(added_obj, ADDED_OBJ)
147 : :
148 : 35 : static int added_obj_cmp(const ADDED_OBJ *ca, const ADDED_OBJ *cb)
149 : : {
150 : : ASN1_OBJECT *a,*b;
151 : : int i;
152 : :
153 : 35 : i=ca->type-cb->type;
154 [ + - ]: 35 : if (i) return(i);
155 : 35 : a=ca->obj;
156 : 35 : b=cb->obj;
157 [ + + - + : 35 : switch (ca->type)
- ]
158 : : {
159 : : case ADDED_DATA:
160 : 6 : i=(a->length - b->length);
161 [ + - ]: 6 : if (i) return(i);
162 : 6 : return(memcmp(a->data,b->data,(size_t)a->length));
163 : : case ADDED_SNAME:
164 [ + - ]: 11 : if (a->sn == NULL) return(-1);
165 [ + - ]: 11 : else if (b->sn == NULL) return(1);
166 : 11 : else return(strcmp(a->sn,b->sn));
167 : : case ADDED_LNAME:
168 [ # # ]: 0 : if (a->ln == NULL) return(-1);
169 [ # # ]: 0 : else if (b->ln == NULL) return(1);
170 : 0 : else return(strcmp(a->ln,b->ln));
171 : : case ADDED_NID:
172 : 18 : return(a->nid-b->nid);
173 : : default:
174 : : /* abort(); */
175 : : return 0;
176 : : }
177 : : }
178 : 70 : static IMPLEMENT_LHASH_COMP_FN(added_obj, ADDED_OBJ)
179 : :
180 : 112 : static int init_added(void)
181 : : {
182 [ + - ]: 112 : if (added != NULL) return(1);
183 : 112 : added=lh_ADDED_OBJ_new();
184 : 112 : return(added != NULL);
185 : : }
186 : :
187 : 1472 : static void cleanup1_doall(ADDED_OBJ *a)
188 : : {
189 : 736 : a->obj->nid=0;
190 : 736 : a->obj->flags|=ASN1_OBJECT_FLAG_DYNAMIC|
191 : : ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
192 : : ASN1_OBJECT_FLAG_DYNAMIC_DATA;
193 : 736 : }
194 : :
195 : 1472 : static void cleanup2_doall(ADDED_OBJ *a)
196 : 736 : { a->obj->nid++; }
197 : :
198 : 736 : static void cleanup3_doall(ADDED_OBJ *a)
199 : : {
200 [ + + ]: 736 : if (--a->obj->nid == 0)
201 : 184 : ASN1_OBJECT_free(a->obj);
202 : 736 : OPENSSL_free(a);
203 : 736 : }
204 : :
205 : 1472 : static IMPLEMENT_LHASH_DOALL_FN(cleanup1, ADDED_OBJ)
206 : 1472 : static IMPLEMENT_LHASH_DOALL_FN(cleanup2, ADDED_OBJ)
207 : 1472 : static IMPLEMENT_LHASH_DOALL_FN(cleanup3, ADDED_OBJ)
208 : :
209 : : /* The purpose of obj_cleanup_defer is to avoid EVP_cleanup() attempting
210 : : * to use freed up OIDs. If necessary the actual freeing up of OIDs is
211 : : * delayed.
212 : : */
213 : :
214 : : int obj_cleanup_defer = 0;
215 : :
216 : 126633 : void check_defer(int nid)
217 : : {
218 [ + - ][ - + ]: 126633 : if (!obj_cleanup_defer && nid >= NUM_NID)
219 : 0 : obj_cleanup_defer = 1;
220 : 126633 : }
221 : :
222 : 862 : void OBJ_cleanup(void)
223 : : {
224 [ - + ]: 862 : if (obj_cleanup_defer)
225 : : {
226 : 0 : obj_cleanup_defer = 2;
227 : 0 : return ;
228 : : }
229 [ + + ]: 862 : if (added == NULL) return;
230 : 112 : lh_ADDED_OBJ_down_load(added) = 0;
231 : 112 : lh_ADDED_OBJ_doall(added,LHASH_DOALL_FN(cleanup1)); /* zero counters */
232 : 112 : lh_ADDED_OBJ_doall(added,LHASH_DOALL_FN(cleanup2)); /* set counters */
233 : 112 : lh_ADDED_OBJ_doall(added,LHASH_DOALL_FN(cleanup3)); /* free objects */
234 : 112 : lh_ADDED_OBJ_free(added);
235 : 112 : added=NULL;
236 : : }
237 : :
238 : 184 : int OBJ_new_nid(int num)
239 : : {
240 : : int i;
241 : :
242 : 184 : i=new_nid;
243 : 184 : new_nid+=num;
244 : 184 : return(i);
245 : : }
246 : :
247 : 184 : int OBJ_add_object(const ASN1_OBJECT *obj)
248 : : {
249 : : ASN1_OBJECT *o;
250 : 184 : ADDED_OBJ *ao[4]={NULL,NULL,NULL,NULL},*aop;
251 : : int i;
252 : :
253 [ + + ]: 184 : if (added == NULL)
254 [ + - ]: 112 : if (!init_added()) return(0);
255 [ + - ]: 184 : if ((o=OBJ_dup(obj)) == NULL) goto err;
256 [ + - ]: 184 : if (!(ao[ADDED_NID]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
257 [ + - ][ + - ]: 184 : if ((o->length != 0) && (obj->data != NULL))
258 [ + - ]: 184 : if (!(ao[ADDED_DATA]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
259 [ + - ]: 184 : if (o->sn != NULL)
260 [ + - ]: 184 : if (!(ao[ADDED_SNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
261 [ + - ]: 184 : if (o->ln != NULL)
262 [ + - ]: 184 : if (!(ao[ADDED_LNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
263 : :
264 [ + + ]: 920 : for (i=ADDED_DATA; i<=ADDED_NID; i++)
265 : : {
266 [ + - ]: 736 : if (ao[i] != NULL)
267 : : {
268 : 736 : ao[i]->type=i;
269 : 736 : ao[i]->obj=o;
270 : 736 : aop=lh_ADDED_OBJ_insert(added,ao[i]);
271 : : /* memory leak, buit should not normally matter */
272 [ - + ]: 736 : if (aop != NULL)
273 : 0 : OPENSSL_free(aop);
274 : : }
275 : : }
276 : 184 : o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
277 : : ASN1_OBJECT_FLAG_DYNAMIC_DATA);
278 : :
279 : 184 : return(o->nid);
280 : : err2:
281 : 0 : OBJerr(OBJ_F_OBJ_ADD_OBJECT,ERR_R_MALLOC_FAILURE);
282 : : err:
283 [ # # ]: 0 : for (i=ADDED_DATA; i<=ADDED_NID; i++)
284 [ # # ]: 0 : if (ao[i] != NULL) OPENSSL_free(ao[i]);
285 [ # # ]: 0 : if (o != NULL) OPENSSL_free(o);
286 : : return(NID_undef);
287 : : }
288 : :
289 : 238191 : ASN1_OBJECT *OBJ_nid2obj(int n)
290 : : {
291 : : ADDED_OBJ ad,*adp;
292 : : ASN1_OBJECT ob;
293 : :
294 [ + + ]: 238191 : if ((n >= 0) && (n < NUM_NID))
295 : : {
296 [ + + ][ - + ]: 238180 : if ((n != NID_undef) && (nid_objs[n].nid == NID_undef))
297 : : {
298 : 0 : OBJerr(OBJ_F_OBJ_NID2OBJ,OBJ_R_UNKNOWN_NID);
299 : 0 : return(NULL);
300 : : }
301 : 238180 : return((ASN1_OBJECT *)&(nid_objs[n]));
302 : : }
303 [ + - ]: 11 : else if (added == NULL)
304 : : return(NULL);
305 : : else
306 : : {
307 : 11 : ad.type=ADDED_NID;
308 : 11 : ad.obj= &ob;
309 : 11 : ob.nid=n;
310 : 11 : adp=lh_ADDED_OBJ_retrieve(added,&ad);
311 [ + - ]: 11 : if (adp != NULL)
312 : 11 : return(adp->obj);
313 : : else
314 : : {
315 : 0 : OBJerr(OBJ_F_OBJ_NID2OBJ,OBJ_R_UNKNOWN_NID);
316 : 0 : return(NULL);
317 : : }
318 : : }
319 : : }
320 : :
321 : 156261 : const char *OBJ_nid2sn(int n)
322 : : {
323 : : ADDED_OBJ ad,*adp;
324 : : ASN1_OBJECT ob;
325 : :
326 [ + - ]: 156261 : if ((n >= 0) && (n < NUM_NID))
327 : : {
328 [ + - ][ - + ]: 156261 : if ((n != NID_undef) && (nid_objs[n].nid == NID_undef))
329 : : {
330 : 0 : OBJerr(OBJ_F_OBJ_NID2SN,OBJ_R_UNKNOWN_NID);
331 : 0 : return(NULL);
332 : : }
333 : 156261 : return(nid_objs[n].sn);
334 : : }
335 [ # # ]: 0 : else if (added == NULL)
336 : : return(NULL);
337 : : else
338 : : {
339 : 0 : ad.type=ADDED_NID;
340 : 0 : ad.obj= &ob;
341 : 0 : ob.nid=n;
342 : 0 : adp=lh_ADDED_OBJ_retrieve(added,&ad);
343 [ # # ]: 0 : if (adp != NULL)
344 : 0 : return(adp->obj->sn);
345 : : else
346 : : {
347 : 0 : OBJerr(OBJ_F_OBJ_NID2SN,OBJ_R_UNKNOWN_NID);
348 : 0 : return(NULL);
349 : : }
350 : : }
351 : : }
352 : :
353 : 126964 : const char *OBJ_nid2ln(int n)
354 : : {
355 : : ADDED_OBJ ad,*adp;
356 : : ASN1_OBJECT ob;
357 : :
358 [ + + ]: 126964 : if ((n >= 0) && (n < NUM_NID))
359 : : {
360 [ + - ][ - + ]: 126957 : if ((n != NID_undef) && (nid_objs[n].nid == NID_undef))
361 : : {
362 : 0 : OBJerr(OBJ_F_OBJ_NID2LN,OBJ_R_UNKNOWN_NID);
363 : 0 : return(NULL);
364 : : }
365 : 126957 : return(nid_objs[n].ln);
366 : : }
367 [ + - ]: 7 : else if (added == NULL)
368 : : return(NULL);
369 : : else
370 : : {
371 : 7 : ad.type=ADDED_NID;
372 : 7 : ad.obj= &ob;
373 : 7 : ob.nid=n;
374 : 7 : adp=lh_ADDED_OBJ_retrieve(added,&ad);
375 [ + - ]: 7 : if (adp != NULL)
376 : 7 : return(adp->obj->ln);
377 : : else
378 : : {
379 : 0 : OBJerr(OBJ_F_OBJ_NID2LN,OBJ_R_UNKNOWN_NID);
380 : 0 : return(NULL);
381 : : }
382 : : }
383 : : }
384 : :
385 : 2060570 : static int obj_cmp(const ASN1_OBJECT * const *ap, const unsigned int *bp)
386 : : {
387 : : int j;
388 : 2060570 : const ASN1_OBJECT *a= *ap;
389 : 2060570 : const ASN1_OBJECT *b= &nid_objs[*bp];
390 : :
391 : 2060570 : j=(a->length - b->length);
392 [ + + ]: 2060570 : if (j) return(j);
393 : 1388025 : return(memcmp(a->data,b->data,a->length));
394 : : }
395 : :
396 : 4597348 : IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
397 : :
398 : 262794 : int OBJ_obj2nid(const ASN1_OBJECT *a)
399 : : {
400 : : const unsigned int *op;
401 : : ADDED_OBJ ad,*adp;
402 : :
403 [ + - ]: 262794 : if (a == NULL)
404 : : return(NID_undef);
405 [ + + ]: 262794 : if (a->nid != 0)
406 : : return(a->nid);
407 : :
408 [ + + ]: 238110 : if (added != NULL)
409 : : {
410 : 1638 : ad.type=ADDED_DATA;
411 : 1638 : ad.obj=(ASN1_OBJECT *)a; /* XXX: ugly but harmless */
412 : 1638 : adp=lh_ADDED_OBJ_retrieve(added,&ad);
413 [ + + ]: 1638 : if (adp != NULL) return (adp->obj->nid);
414 : : }
415 : 238104 : op=OBJ_bsearch_obj(&a, obj_objs, NUM_OBJ);
416 [ + - ]: 238104 : if (op == NULL)
417 : : return(NID_undef);
418 : 238104 : return(nid_objs[*op].nid);
419 : : }
420 : :
421 : : /* Convert an object name into an ASN1_OBJECT
422 : : * if "noname" is not set then search for short and long names first.
423 : : * This will convert the "dotted" form into an object: unlike OBJ_txt2nid
424 : : * it can be used with any objects, not just registered ones.
425 : : */
426 : :
427 : 83 : ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name)
428 : : {
429 : 83 : int nid = NID_undef;
430 : 83 : ASN1_OBJECT *op=NULL;
431 : : unsigned char *buf;
432 : : unsigned char *p;
433 : : const unsigned char *cp;
434 : : int i, j;
435 : :
436 [ + - ]: 83 : if(!no_name) {
437 [ + + ][ + - ]: 83 : if( ((nid = OBJ_sn2nid(s)) != NID_undef) ||
438 : : ((nid = OBJ_ln2nid(s)) != NID_undef) )
439 : 83 : return OBJ_nid2obj(nid);
440 : : }
441 : :
442 : : /* Work out size of content octets */
443 : 0 : i=a2d_ASN1_OBJECT(NULL,0,s,-1);
444 [ # # ]: 0 : if (i <= 0) {
445 : : /* Don't clear the error */
446 : : /*ERR_clear_error();*/
447 : : return NULL;
448 : : }
449 : : /* Work out total size */
450 : 0 : j = ASN1_object_size(0,i,V_ASN1_OBJECT);
451 : :
452 [ # # ]: 0 : if((buf=(unsigned char *)OPENSSL_malloc(j)) == NULL) return NULL;
453 : :
454 : 0 : p = buf;
455 : : /* Write out tag+length */
456 : 0 : ASN1_put_object(&p,0,i,V_ASN1_OBJECT,V_ASN1_UNIVERSAL);
457 : : /* Write out contents */
458 : 0 : a2d_ASN1_OBJECT(p,i,s,-1);
459 : :
460 : 0 : cp=buf;
461 : 0 : op=d2i_ASN1_OBJECT(NULL,&cp,j);
462 : 0 : OPENSSL_free(buf);
463 : 0 : return op;
464 : : }
465 : :
466 : 316 : int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name)
467 : : {
468 : 316 : int i,n=0,len,nid, first, use_bn;
469 : : BIGNUM *bl;
470 : : unsigned long l;
471 : : const unsigned char *p;
472 : : char tbuf[DECIMAL_SIZE(i)+DECIMAL_SIZE(l)+2];
473 : :
474 [ + - ][ - + ]: 316 : if ((a == NULL) || (a->data == NULL)) {
475 : 0 : buf[0]='\0';
476 : 0 : return(0);
477 : : }
478 : :
479 : :
480 [ + - ][ + - ]: 316 : if (!no_name && (nid=OBJ_obj2nid(a)) != NID_undef)
481 : : {
482 : : const char *s;
483 : 316 : s=OBJ_nid2ln(nid);
484 [ - + ]: 316 : if (s == NULL)
485 : 0 : s=OBJ_nid2sn(nid);
486 [ + - ]: 316 : if (s)
487 : : {
488 [ + - ]: 316 : if (buf)
489 : 316 : BUF_strlcpy(buf,s,buf_len);
490 : 316 : n=strlen(s);
491 : 316 : return n;
492 : : }
493 : : }
494 : :
495 : :
496 : 0 : len=a->length;
497 : 0 : p=a->data;
498 : :
499 : 0 : first = 1;
500 : 0 : bl = NULL;
501 : :
502 [ # # ]: 0 : while (len > 0)
503 : : {
504 : : l=0;
505 : : use_bn = 0;
506 : : for (;;)
507 : : {
508 : 0 : unsigned char c = *p++;
509 : 0 : len--;
510 [ # # ]: 0 : if ((len == 0) && (c & 0x80))
511 : : goto err;
512 [ # # ]: 0 : if (use_bn)
513 : : {
514 [ # # ]: 0 : if (!BN_add_word(bl, c & 0x7f))
515 : : goto err;
516 : : }
517 : : else
518 : 0 : l |= c & 0x7f;
519 [ # # ]: 0 : if (!(c & 0x80))
520 : : break;
521 [ # # ]: 0 : if (!use_bn && (l > (ULONG_MAX >> 7L)))
522 : : {
523 [ # # ][ # # ]: 0 : if (!bl && !(bl = BN_new()))
524 : : goto err;
525 [ # # ]: 0 : if (!BN_set_word(bl, l))
526 : : goto err;
527 : : use_bn = 1;
528 : : }
529 [ # # ]: 0 : if (use_bn)
530 : : {
531 [ # # ]: 0 : if (!BN_lshift(bl, bl, 7))
532 : : goto err;
533 : : }
534 : : else
535 : 0 : l<<=7L;
536 : : }
537 : :
538 [ # # ]: 0 : if (first)
539 : : {
540 : 0 : first = 0;
541 [ # # ]: 0 : if (l >= 80)
542 : : {
543 : 0 : i = 2;
544 [ # # ]: 0 : if (use_bn)
545 : : {
546 [ # # ]: 0 : if (!BN_sub_word(bl, 80))
547 : : goto err;
548 : : }
549 : : else
550 : 0 : l -= 80;
551 : : }
552 : : else
553 : : {
554 : 0 : i=(int)(l/40);
555 : 0 : l-=(long)(i*40);
556 : : }
557 [ # # ]: 0 : if (buf && (buf_len > 0))
558 : : {
559 : 0 : *buf++ = i + '0';
560 : 0 : buf_len--;
561 : : }
562 : 0 : n++;
563 : : }
564 : :
565 [ # # ]: 0 : if (use_bn)
566 : : {
567 : : char *bndec;
568 : 0 : bndec = BN_bn2dec(bl);
569 [ # # ]: 0 : if (!bndec)
570 : : goto err;
571 : 0 : i = strlen(bndec);
572 [ # # ]: 0 : if (buf)
573 : : {
574 [ # # ]: 0 : if (buf_len > 0)
575 : : {
576 : 0 : *buf++ = '.';
577 : 0 : buf_len--;
578 : : }
579 : 0 : BUF_strlcpy(buf,bndec,buf_len);
580 [ # # ]: 0 : if (i > buf_len)
581 : : {
582 : 0 : buf += buf_len;
583 : 0 : buf_len = 0;
584 : : }
585 : : else
586 : : {
587 : 0 : buf+=i;
588 : 0 : buf_len-=i;
589 : : }
590 : : }
591 : 0 : n++;
592 : 0 : n += i;
593 : 0 : OPENSSL_free(bndec);
594 : : }
595 : : else
596 : : {
597 : 0 : BIO_snprintf(tbuf,sizeof tbuf,".%lu",l);
598 : 0 : i=strlen(tbuf);
599 [ # # ]: 0 : if (buf && (buf_len > 0))
600 : : {
601 : 0 : BUF_strlcpy(buf,tbuf,buf_len);
602 [ # # ]: 0 : if (i > buf_len)
603 : : {
604 : 0 : buf += buf_len;
605 : 0 : buf_len = 0;
606 : : }
607 : : else
608 : : {
609 : 0 : buf+=i;
610 : 0 : buf_len-=i;
611 : : }
612 : : }
613 : 0 : n+=i;
614 : 0 : l=0;
615 : : }
616 : : }
617 : :
618 [ # # ]: 0 : if (bl)
619 : 0 : BN_free(bl);
620 : 0 : return n;
621 : :
622 : : err:
623 [ # # ]: 0 : if (bl)
624 : 0 : BN_free(bl);
625 : : return -1;
626 : : }
627 : :
628 : 51 : int OBJ_txt2nid(const char *s)
629 : : {
630 : : ASN1_OBJECT *obj;
631 : : int nid;
632 : 51 : obj = OBJ_txt2obj(s, 0);
633 : 51 : nid = OBJ_obj2nid(obj);
634 : 51 : ASN1_OBJECT_free(obj);
635 : 51 : return nid;
636 : : }
637 : :
638 : 58 : int OBJ_ln2nid(const char *s)
639 : : {
640 : : ASN1_OBJECT o;
641 : 58 : const ASN1_OBJECT *oo= &o;
642 : : ADDED_OBJ ad,*adp;
643 : : const unsigned int *op;
644 : :
645 : 58 : o.ln=s;
646 [ + + ]: 58 : if (added != NULL)
647 : : {
648 : 21 : ad.type=ADDED_LNAME;
649 : 21 : ad.obj= &o;
650 : 21 : adp=lh_ADDED_OBJ_retrieve(added,&ad);
651 [ - + ]: 21 : if (adp != NULL) return (adp->obj->nid);
652 : : }
653 : 58 : op=OBJ_bsearch_ln(&oo, ln_objs, NUM_LN);
654 [ + - ]: 58 : if (op == NULL) return(NID_undef);
655 : 58 : return(nid_objs[*op].nid);
656 : : }
657 : :
658 : 219 : int OBJ_sn2nid(const char *s)
659 : : {
660 : : ASN1_OBJECT o;
661 : 219 : const ASN1_OBJECT *oo= &o;
662 : : ADDED_OBJ ad,*adp;
663 : : const unsigned int *op;
664 : :
665 : 219 : o.sn=s;
666 [ + + ]: 219 : if (added != NULL)
667 : : {
668 : 135 : ad.type=ADDED_SNAME;
669 : 135 : ad.obj= &o;
670 : 135 : adp=lh_ADDED_OBJ_retrieve(added,&ad);
671 [ + + ]: 135 : if (adp != NULL) return (adp->obj->nid);
672 : : }
673 : 208 : op=OBJ_bsearch_sn(&oo, sn_objs, NUM_SN);
674 [ + + ]: 208 : if (op == NULL) return(NID_undef);
675 : 150 : return(nid_objs[*op].nid);
676 : : }
677 : :
678 : 396801 : const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
679 : : int (*cmp)(const void *, const void *))
680 : : {
681 : 396801 : return OBJ_bsearch_ex_(key, base, num, size, cmp, 0);
682 : : }
683 : :
684 : 404236 : const void *OBJ_bsearch_ex_(const void *key, const void *base_, int num,
685 : : int size,
686 : : int (*cmp)(const void *, const void *),
687 : : int flags)
688 : : {
689 : 404236 : const char *base=base_;
690 : 404236 : int l,h,i=0,c=0;
691 : 404236 : const char *p = NULL;
692 : :
693 [ + + ]: 404236 : if (num == 0) return(NULL);
694 : : l=0;
695 : : h=num;
696 [ + + ]: 2791881 : while (l < h)
697 : : {
698 : 2790664 : i=(l+h)/2;
699 : 2790664 : p= &(base[i*size]);
700 : 2790664 : c=(*cmp)(key,p);
701 [ + + ]: 2790664 : if (c < 0)
702 : : h=i;
703 [ + + ]: 1395064 : else if (c > 0)
704 : 2392009 : l=i+1;
705 : : else
706 : : break;
707 : : }
708 : : #ifdef CHARSET_EBCDIC
709 : : /* THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and
710 : : * I don't have perl (yet), we revert to a *LINEAR* search
711 : : * when the object wasn't found in the binary search.
712 : : */
713 : : if (c != 0)
714 : : {
715 : : for (i=0; i<num; ++i)
716 : : {
717 : : p= &(base[i*size]);
718 : : c = (*cmp)(key,p);
719 : : if (c == 0 || (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)))
720 : : return p;
721 : : }
722 : : }
723 : : #endif
724 [ + + ][ - + ]: 399872 : if (c != 0 && !(flags & OBJ_BSEARCH_VALUE_ON_NOMATCH))
725 : : p = NULL;
726 [ + - ][ + + ]: 398655 : else if (c == 0 && (flags & OBJ_BSEARCH_FIRST_VALUE_ON_MATCH))
727 : : {
728 [ + + ][ - + ]: 2429 : while(i > 0 && (*cmp)(key,&(base[(i-1)*size])) == 0)
729 : : i--;
730 : 2429 : p = &(base[i*size]);
731 : : }
732 : 399872 : return(p);
733 : : }
734 : :
735 : 0 : int OBJ_create_objects(BIO *in)
736 : : {
737 : : MS_STATIC char buf[512];
738 : 0 : int i,num=0;
739 : 0 : char *o,*s,*l=NULL;
740 : :
741 : : for (;;)
742 : : {
743 : 0 : s=o=NULL;
744 : 0 : i=BIO_gets(in,buf,512);
745 [ # # ]: 0 : if (i <= 0) return(num);
746 : 0 : buf[i-1]='\0';
747 [ # # ]: 0 : if (!isalnum((unsigned char)buf[0])) return(num);
748 : : o=s=buf;
749 [ # # ][ # # ]: 0 : while (isdigit((unsigned char)*s) || (*s == '.'))
750 : 0 : s++;
751 [ # # ]: 0 : if (*s != '\0')
752 : : {
753 : 0 : *(s++)='\0';
754 [ # # ]: 0 : while (isspace((unsigned char)*s))
755 : 0 : s++;
756 [ # # ]: 0 : if (*s == '\0')
757 : : s=NULL;
758 : : else
759 : : {
760 : : l=s;
761 [ # # ][ # # ]: 0 : while ((*l != '\0') && !isspace((unsigned char)*l))
762 : 0 : l++;
763 [ # # ]: 0 : if (*l != '\0')
764 : : {
765 : 0 : *(l++)='\0';
766 [ # # ]: 0 : while (isspace((unsigned char)*l))
767 : 0 : l++;
768 [ # # ]: 0 : if (*l == '\0') l=NULL;
769 : : }
770 : : else
771 : : l=NULL;
772 : : }
773 : : }
774 : : else
775 : : s=NULL;
776 [ # # ]: 0 : if ((o == NULL) || (*o == '\0')) return(num);
777 [ # # ]: 0 : if (!OBJ_create(o,s,l)) return(num);
778 : 0 : num++;
779 : 0 : }
780 : : /* return(num); */
781 : : }
782 : :
783 : 184 : int OBJ_create(const char *oid, const char *sn, const char *ln)
784 : : {
785 : 184 : int ok=0;
786 : 184 : ASN1_OBJECT *op=NULL;
787 : : unsigned char *buf;
788 : : int i;
789 : :
790 : 184 : i=a2d_ASN1_OBJECT(NULL,0,oid,-1);
791 [ + - ]: 184 : if (i <= 0) return(0);
792 : :
793 [ - + ]: 184 : if ((buf=(unsigned char *)OPENSSL_malloc(i)) == NULL)
794 : : {
795 : 0 : OBJerr(OBJ_F_OBJ_CREATE,ERR_R_MALLOC_FAILURE);
796 : 0 : return(0);
797 : : }
798 : 184 : i=a2d_ASN1_OBJECT(buf,i,oid,-1);
799 [ + - ]: 184 : if (i == 0)
800 : : goto err;
801 : 184 : op=(ASN1_OBJECT *)ASN1_OBJECT_create(OBJ_new_nid(1),buf,i,sn,ln);
802 [ + - ]: 184 : if (op == NULL)
803 : : goto err;
804 : 184 : ok=OBJ_add_object(op);
805 : : err:
806 : 184 : ASN1_OBJECT_free(op);
807 : 184 : OPENSSL_free(buf);
808 : 184 : return(ok);
809 : : }
810 : :
|
