Trivial bounds checking.
[openssl.git] / crypto / objects / obj_dat.c
1 /*
2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <ctype.h>
12 #include <limits.h>
13 #include "internal/cryptlib.h"
14 #include <openssl/lhash.h>
15 #include <openssl/asn1.h>
16 #include "internal/objects.h"
17 #include <openssl/bn.h>
18 #include "internal/asn1_int.h"
19 #include "obj_lcl.h"
20
21 /* obj_dat.h is generated from objects.h by obj_dat.pl */
22 #include "obj_dat.h"
23
24 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
25 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
26 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
27
28 #define ADDED_DATA      0
29 #define ADDED_SNAME     1
30 #define ADDED_LNAME     2
31 #define ADDED_NID       3
32
33 struct added_obj_st {
34     int type;
35     ASN1_OBJECT *obj;
36 };
37
38 static int new_nid = NUM_NID;
39 static LHASH_OF(ADDED_OBJ) *added = NULL;
40
41 static int sn_cmp(const ASN1_OBJECT *const *a, const unsigned int *b)
42 {
43     return strcmp((*a)->sn, nid_objs[*b].sn);
44 }
45
46 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
47
48 static int ln_cmp(const ASN1_OBJECT *const *a, const unsigned int *b)
49 {
50     return strcmp((*a)->ln, nid_objs[*b].ln);
51 }
52
53 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
54
55 static unsigned long added_obj_hash(const ADDED_OBJ *ca)
56 {
57     const ASN1_OBJECT *a;
58     int i;
59     unsigned long ret = 0;
60     unsigned char *p;
61
62     a = ca->obj;
63     switch (ca->type) {
64     case ADDED_DATA:
65         ret = a->length << 20L;
66         p = (unsigned char *)a->data;
67         for (i = 0; i < a->length; i++)
68             ret ^= p[i] << ((i * 3) % 24);
69         break;
70     case ADDED_SNAME:
71         ret = OPENSSL_LH_strhash(a->sn);
72         break;
73     case ADDED_LNAME:
74         ret = OPENSSL_LH_strhash(a->ln);
75         break;
76     case ADDED_NID:
77         ret = a->nid;
78         break;
79     default:
80         /* abort(); */
81         return 0;
82     }
83     ret &= 0x3fffffffL;
84     ret |= ((unsigned long)ca->type) << 30L;
85     return ret;
86 }
87
88 static int added_obj_cmp(const ADDED_OBJ *ca, const ADDED_OBJ *cb)
89 {
90     ASN1_OBJECT *a, *b;
91     int i;
92
93     i = ca->type - cb->type;
94     if (i)
95         return i;
96     a = ca->obj;
97     b = cb->obj;
98     switch (ca->type) {
99     case ADDED_DATA:
100         i = (a->length - b->length);
101         if (i)
102             return i;
103         return memcmp(a->data, b->data, (size_t)a->length);
104     case ADDED_SNAME:
105         if (a->sn == NULL)
106             return -1;
107         else if (b->sn == NULL)
108             return 1;
109         else
110             return strcmp(a->sn, b->sn);
111     case ADDED_LNAME:
112         if (a->ln == NULL)
113             return -1;
114         else if (b->ln == NULL)
115             return 1;
116         else
117             return strcmp(a->ln, b->ln);
118     case ADDED_NID:
119         return a->nid - b->nid;
120     default:
121         /* abort(); */
122         return 0;
123     }
124 }
125
126 static int init_added(void)
127 {
128     if (added != NULL)
129         return 1;
130     added = lh_ADDED_OBJ_new(added_obj_hash, added_obj_cmp);
131     return added != NULL;
132 }
133
134 static void cleanup1_doall(ADDED_OBJ *a)
135 {
136     a->obj->nid = 0;
137     a->obj->flags |= ASN1_OBJECT_FLAG_DYNAMIC |
138         ASN1_OBJECT_FLAG_DYNAMIC_STRINGS | ASN1_OBJECT_FLAG_DYNAMIC_DATA;
139 }
140
141 static void cleanup2_doall(ADDED_OBJ *a)
142 {
143     a->obj->nid++;
144 }
145
146 static void cleanup3_doall(ADDED_OBJ *a)
147 {
148     if (--a->obj->nid == 0)
149         ASN1_OBJECT_free(a->obj);
150     OPENSSL_free(a);
151 }
152
153 void obj_cleanup_int(void)
154 {
155     if (added == NULL)
156         return;
157     lh_ADDED_OBJ_set_down_load(added, 0);
158     lh_ADDED_OBJ_doall(added, cleanup1_doall); /* zero counters */
159     lh_ADDED_OBJ_doall(added, cleanup2_doall); /* set counters */
160     lh_ADDED_OBJ_doall(added, cleanup3_doall); /* free objects */
161     lh_ADDED_OBJ_free(added);
162     added = NULL;
163 }
164
165 int OBJ_new_nid(int num)
166 {
167     int i;
168
169     i = new_nid;
170     new_nid += num;
171     return i;
172 }
173
174 int OBJ_add_object(const ASN1_OBJECT *obj)
175 {
176     ASN1_OBJECT *o;
177     ADDED_OBJ *ao[4] = { NULL, NULL, NULL, NULL }, *aop;
178     int i;
179
180     if (added == NULL)
181         if (!init_added())
182             return 0;
183     if ((o = OBJ_dup(obj)) == NULL)
184         goto err;
185     if ((ao[ADDED_NID] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
186         goto err2;
187     if ((o->length != 0) && (obj->data != NULL))
188         if ((ao[ADDED_DATA] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
189             goto err2;
190     if (o->sn != NULL)
191         if ((ao[ADDED_SNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
192             goto err2;
193     if (o->ln != NULL)
194         if ((ao[ADDED_LNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
195             goto err2;
196
197     for (i = ADDED_DATA; i <= ADDED_NID; i++) {
198         if (ao[i] != NULL) {
199             ao[i]->type = i;
200             ao[i]->obj = o;
201             aop = lh_ADDED_OBJ_insert(added, ao[i]);
202             /* memory leak, but should not normally matter */
203             OPENSSL_free(aop);
204         }
205     }
206     o->flags &=
207         ~(ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
208           ASN1_OBJECT_FLAG_DYNAMIC_DATA);
209
210     return o->nid;
211  err2:
212     OBJerr(OBJ_F_OBJ_ADD_OBJECT, ERR_R_MALLOC_FAILURE);
213  err:
214     for (i = ADDED_DATA; i <= ADDED_NID; i++)
215         OPENSSL_free(ao[i]);
216     OPENSSL_free(o);
217     return NID_undef;
218 }
219
220 ASN1_OBJECT *OBJ_nid2obj(int n)
221 {
222     ADDED_OBJ ad, *adp;
223     ASN1_OBJECT ob;
224
225     if ((n >= 0) && (n < NUM_NID)) {
226         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
227             OBJerr(OBJ_F_OBJ_NID2OBJ, OBJ_R_UNKNOWN_NID);
228             return NULL;
229         }
230         return (ASN1_OBJECT *)&(nid_objs[n]);
231     } else if (added == NULL)
232         return NULL;
233     else {
234         ad.type = ADDED_NID;
235         ad.obj = &ob;
236         ob.nid = n;
237         adp = lh_ADDED_OBJ_retrieve(added, &ad);
238         if (adp != NULL)
239             return adp->obj;
240         else {
241             OBJerr(OBJ_F_OBJ_NID2OBJ, OBJ_R_UNKNOWN_NID);
242             return NULL;
243         }
244     }
245 }
246
247 const char *OBJ_nid2sn(int n)
248 {
249     ADDED_OBJ ad, *adp;
250     ASN1_OBJECT ob;
251
252     if ((n >= 0) && (n < NUM_NID)) {
253         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
254             OBJerr(OBJ_F_OBJ_NID2SN, OBJ_R_UNKNOWN_NID);
255             return NULL;
256         }
257         return nid_objs[n].sn;
258     } else if (added == NULL)
259         return NULL;
260     else {
261         ad.type = ADDED_NID;
262         ad.obj = &ob;
263         ob.nid = n;
264         adp = lh_ADDED_OBJ_retrieve(added, &ad);
265         if (adp != NULL)
266             return adp->obj->sn;
267         else {
268             OBJerr(OBJ_F_OBJ_NID2SN, OBJ_R_UNKNOWN_NID);
269             return NULL;
270         }
271     }
272 }
273
274 const char *OBJ_nid2ln(int n)
275 {
276     ADDED_OBJ ad, *adp;
277     ASN1_OBJECT ob;
278
279     if ((n >= 0) && (n < NUM_NID)) {
280         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
281             OBJerr(OBJ_F_OBJ_NID2LN, OBJ_R_UNKNOWN_NID);
282             return NULL;
283         }
284         return nid_objs[n].ln;
285     } else if (added == NULL)
286         return NULL;
287     else {
288         ad.type = ADDED_NID;
289         ad.obj = &ob;
290         ob.nid = n;
291         adp = lh_ADDED_OBJ_retrieve(added, &ad);
292         if (adp != NULL)
293             return adp->obj->ln;
294         else {
295             OBJerr(OBJ_F_OBJ_NID2LN, OBJ_R_UNKNOWN_NID);
296             return NULL;
297         }
298     }
299 }
300
301 static int obj_cmp(const ASN1_OBJECT *const *ap, const unsigned int *bp)
302 {
303     int j;
304     const ASN1_OBJECT *a = *ap;
305     const ASN1_OBJECT *b = &nid_objs[*bp];
306
307     j = (a->length - b->length);
308     if (j)
309         return j;
310     if (a->length == 0)
311         return 0;
312     return memcmp(a->data, b->data, a->length);
313 }
314
315 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
316
317 int OBJ_obj2nid(const ASN1_OBJECT *a)
318 {
319     const unsigned int *op;
320     ADDED_OBJ ad, *adp;
321
322     if (a == NULL)
323         return NID_undef;
324     if (a->nid != 0)
325         return a->nid;
326
327     if (a->length == 0)
328         return NID_undef;
329
330     if (added != NULL) {
331         ad.type = ADDED_DATA;
332         ad.obj = (ASN1_OBJECT *)a; /* XXX: ugly but harmless */
333         adp = lh_ADDED_OBJ_retrieve(added, &ad);
334         if (adp != NULL)
335             return adp->obj->nid;
336     }
337     op = OBJ_bsearch_obj(&a, obj_objs, NUM_OBJ);
338     if (op == NULL)
339         return NID_undef;
340     return nid_objs[*op].nid;
341 }
342
343 /*
344  * Convert an object name into an ASN1_OBJECT if "noname" is not set then
345  * search for short and long names first. This will convert the "dotted" form
346  * into an object: unlike OBJ_txt2nid it can be used with any objects, not
347  * just registered ones.
348  */
349
350 ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name)
351 {
352     int nid = NID_undef;
353     ASN1_OBJECT *op = NULL;
354     unsigned char *buf;
355     unsigned char *p;
356     const unsigned char *cp;
357     int i, j;
358
359     if (!no_name) {
360         if (((nid = OBJ_sn2nid(s)) != NID_undef) ||
361             ((nid = OBJ_ln2nid(s)) != NID_undef))
362             return OBJ_nid2obj(nid);
363     }
364
365     /* Work out size of content octets */
366     i = a2d_ASN1_OBJECT(NULL, 0, s, -1);
367     if (i <= 0) {
368         /* Don't clear the error */
369         /*
370          * ERR_clear_error();
371          */
372         return NULL;
373     }
374     /* Work out total size */
375     j = ASN1_object_size(0, i, V_ASN1_OBJECT);
376     if (j < 0)
377         return NULL;
378
379     if ((buf = OPENSSL_malloc(j)) == NULL)
380         return NULL;
381
382     p = buf;
383     /* Write out tag+length */
384     ASN1_put_object(&p, 0, i, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
385     /* Write out contents */
386     a2d_ASN1_OBJECT(p, i, s, -1);
387
388     cp = buf;
389     op = d2i_ASN1_OBJECT(NULL, &cp, j);
390     OPENSSL_free(buf);
391     return op;
392 }
393
394 int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name)
395 {
396     int i, n = 0, len, nid, first, use_bn;
397     BIGNUM *bl;
398     unsigned long l;
399     const unsigned char *p;
400     char tbuf[DECIMAL_SIZE(i) + DECIMAL_SIZE(l) + 2];
401
402     /* Ensure that, at every state, |buf| is NUL-terminated. */
403     if (buf && buf_len > 0)
404         buf[0] = '\0';
405
406     if ((a == NULL) || (a->data == NULL))
407         return 0;
408
409     if (!no_name && (nid = OBJ_obj2nid(a)) != NID_undef) {
410         const char *s;
411         s = OBJ_nid2ln(nid);
412         if (s == NULL)
413             s = OBJ_nid2sn(nid);
414         if (s) {
415             if (buf)
416                 OPENSSL_strlcpy(buf, s, buf_len);
417             n = strlen(s);
418             return n;
419         }
420     }
421
422     len = a->length;
423     p = a->data;
424
425     first = 1;
426     bl = NULL;
427
428     while (len > 0) {
429         l = 0;
430         use_bn = 0;
431         for (;;) {
432             unsigned char c = *p++;
433             len--;
434             if ((len == 0) && (c & 0x80))
435                 goto err;
436             if (use_bn) {
437                 if (!BN_add_word(bl, c & 0x7f))
438                     goto err;
439             } else
440                 l |= c & 0x7f;
441             if (!(c & 0x80))
442                 break;
443             if (!use_bn && (l > (ULONG_MAX >> 7L))) {
444                 if (bl == NULL && (bl = BN_new()) == NULL)
445                     goto err;
446                 if (!BN_set_word(bl, l))
447                     goto err;
448                 use_bn = 1;
449             }
450             if (use_bn) {
451                 if (!BN_lshift(bl, bl, 7))
452                     goto err;
453             } else
454                 l <<= 7L;
455         }
456
457         if (first) {
458             first = 0;
459             if (l >= 80) {
460                 i = 2;
461                 if (use_bn) {
462                     if (!BN_sub_word(bl, 80))
463                         goto err;
464                 } else
465                     l -= 80;
466             } else {
467                 i = (int)(l / 40);
468                 l -= (long)(i * 40);
469             }
470             if (buf && (buf_len > 1)) {
471                 *buf++ = i + '0';
472                 *buf = '\0';
473                 buf_len--;
474             }
475             n++;
476         }
477
478         if (use_bn) {
479             char *bndec;
480             bndec = BN_bn2dec(bl);
481             if (!bndec)
482                 goto err;
483             i = strlen(bndec);
484             if (buf) {
485                 if (buf_len > 1) {
486                     *buf++ = '.';
487                     *buf = '\0';
488                     buf_len--;
489                 }
490                 OPENSSL_strlcpy(buf, bndec, buf_len);
491                 if (i > buf_len) {
492                     buf += buf_len;
493                     buf_len = 0;
494                 } else {
495                     buf += i;
496                     buf_len -= i;
497                 }
498             }
499             n++;
500             n += i;
501             OPENSSL_free(bndec);
502         } else {
503             BIO_snprintf(tbuf, sizeof(tbuf), ".%lu", l);
504             i = strlen(tbuf);
505             if (buf && (buf_len > 0)) {
506                 OPENSSL_strlcpy(buf, tbuf, buf_len);
507                 if (i > buf_len) {
508                     buf += buf_len;
509                     buf_len = 0;
510                 } else {
511                     buf += i;
512                     buf_len -= i;
513                 }
514             }
515             n += i;
516             l = 0;
517         }
518     }
519
520     BN_free(bl);
521     return n;
522
523  err:
524     BN_free(bl);
525     return -1;
526 }
527
528 int OBJ_txt2nid(const char *s)
529 {
530     ASN1_OBJECT *obj;
531     int nid;
532     obj = OBJ_txt2obj(s, 0);
533     nid = OBJ_obj2nid(obj);
534     ASN1_OBJECT_free(obj);
535     return nid;
536 }
537
538 int OBJ_ln2nid(const char *s)
539 {
540     ASN1_OBJECT o;
541     const ASN1_OBJECT *oo = &o;
542     ADDED_OBJ ad, *adp;
543     const unsigned int *op;
544
545     o.ln = s;
546     if (added != NULL) {
547         ad.type = ADDED_LNAME;
548         ad.obj = &o;
549         adp = lh_ADDED_OBJ_retrieve(added, &ad);
550         if (adp != NULL)
551             return adp->obj->nid;
552     }
553     op = OBJ_bsearch_ln(&oo, ln_objs, NUM_LN);
554     if (op == NULL)
555         return NID_undef;
556     return nid_objs[*op].nid;
557 }
558
559 int OBJ_sn2nid(const char *s)
560 {
561     ASN1_OBJECT o;
562     const ASN1_OBJECT *oo = &o;
563     ADDED_OBJ ad, *adp;
564     const unsigned int *op;
565
566     o.sn = s;
567     if (added != NULL) {
568         ad.type = ADDED_SNAME;
569         ad.obj = &o;
570         adp = lh_ADDED_OBJ_retrieve(added, &ad);
571         if (adp != NULL)
572             return adp->obj->nid;
573     }
574     op = OBJ_bsearch_sn(&oo, sn_objs, NUM_SN);
575     if (op == NULL)
576         return NID_undef;
577     return nid_objs[*op].nid;
578 }
579
580 const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
581                          int (*cmp) (const void *, const void *))
582 {
583     return OBJ_bsearch_ex_(key, base, num, size, cmp, 0);
584 }
585
586 const void *OBJ_bsearch_ex_(const void *key, const void *base_, int num,
587                             int size,
588                             int (*cmp) (const void *, const void *),
589                             int flags)
590 {
591     const char *base = base_;
592     int l, h, i = 0, c = 0;
593     const char *p = NULL;
594
595     if (num == 0)
596         return NULL;
597     l = 0;
598     h = num;
599     while (l < h) {
600         i = (l + h) / 2;
601         p = &(base[i * size]);
602         c = (*cmp) (key, p);
603         if (c < 0)
604             h = i;
605         else if (c > 0)
606             l = i + 1;
607         else
608             break;
609     }
610 #ifdef CHARSET_EBCDIC
611     /*
612      * THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and I
613      * don't have perl (yet), we revert to a *LINEAR* search when the object
614      * wasn't found in the binary search.
615      */
616     if (c != 0) {
617         for (i = 0; i < num; ++i) {
618             p = &(base[i * size]);
619             c = (*cmp) (key, p);
620             if (c == 0 || (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)))
621                 return p;
622         }
623     }
624 #endif
625     if (c != 0 && !(flags & OBJ_BSEARCH_VALUE_ON_NOMATCH))
626         p = NULL;
627     else if (c == 0 && (flags & OBJ_BSEARCH_FIRST_VALUE_ON_MATCH)) {
628         while (i > 0 && (*cmp) (key, &(base[(i - 1) * size])) == 0)
629             i--;
630         p = &(base[i * size]);
631     }
632     return p;
633 }
634
635 int OBJ_create_objects(BIO *in)
636 {
637     char buf[512];
638     int i, num = 0;
639     char *o, *s, *l = NULL;
640
641     for (;;) {
642         s = o = NULL;
643         i = BIO_gets(in, buf, 512);
644         if (i <= 0)
645             return num;
646         buf[i - 1] = '\0';
647         if (!isalnum((unsigned char)buf[0]))
648             return num;
649         o = s = buf;
650         while (isdigit((unsigned char)*s) || (*s == '.'))
651             s++;
652         if (*s != '\0') {
653             *(s++) = '\0';
654             while (isspace((unsigned char)*s))
655                 s++;
656             if (*s == '\0')
657                 s = NULL;
658             else {
659                 l = s;
660                 while ((*l != '\0') && !isspace((unsigned char)*l))
661                     l++;
662                 if (*l != '\0') {
663                     *(l++) = '\0';
664                     while (isspace((unsigned char)*l))
665                         l++;
666                     if (*l == '\0')
667                         l = NULL;
668                 } else
669                     l = NULL;
670             }
671         } else
672             s = NULL;
673         if ((o == NULL) || (*o == '\0'))
674             return num;
675         if (!OBJ_create(o, s, l))
676             return num;
677         num++;
678     }
679 }
680
681 int OBJ_create(const char *oid, const char *sn, const char *ln)
682 {
683     ASN1_OBJECT *tmpoid = NULL;
684     int ok = 0;
685
686     /* Check to see if short or long name already present */
687     if ((sn != NULL && OBJ_sn2nid(sn) != NID_undef)
688             || (ln != NULL && OBJ_ln2nid(ln) != NID_undef)) {
689         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
690         return 0;
691     }
692
693     /* Convert numerical OID string to an ASN1_OBJECT structure */
694     tmpoid = OBJ_txt2obj(oid, 1);
695     if (tmpoid == NULL)
696         return 0;
697
698     /* If NID is not NID_undef then object already exists */
699     if (OBJ_obj2nid(tmpoid) != NID_undef) {
700         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
701         goto err;
702     }
703
704     tmpoid->nid = OBJ_new_nid(1);
705     tmpoid->sn = (char *)sn;
706     tmpoid->ln = (char *)ln;
707
708     ok = OBJ_add_object(tmpoid);
709
710     tmpoid->sn = NULL;
711     tmpoid->ln = NULL;
712
713  err:
714     ASN1_OBJECT_free(tmpoid);
715     return ok;
716 }
717
718 size_t OBJ_length(const ASN1_OBJECT *obj)
719 {
720     if (obj == NULL)
721         return 0;
722     return obj->length;
723 }
724
725 const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj)
726 {
727     if (obj == NULL)
728         return NULL;
729     return obj->data;
730 }