1 /*
2 * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (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 "crypto/ctype.h"
12 #include <limits.h>
13 #include "internal/cryptlib.h"
14 #include "internal/thread_once.h"
15 #include "internal/tsan_assist.h"
16 #include <openssl/lhash.h>
17 #include <openssl/asn1.h>
18 #include "crypto/objects.h"
19 #include <openssl/bn.h>
20 #include "crypto/asn1.h"
21 #include "obj_local.h"
22
23 /* obj_dat.h is generated from objects.txt and obj_mac.{num,h} by obj_dat.pl */
24 #include "obj_dat.h"
25
26 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
27 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
28 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
29
30 #define ADDED_DATA 0
31 #define ADDED_SNAME 1
32 #define ADDED_LNAME 2
33 #define ADDED_NID 3
34
35 struct added_obj_st {
36 int type;
37 ASN1_OBJECT *obj;
38 };
39
40 static LHASH_OF(ADDED_OBJ) *added = NULL;
41 static CRYPTO_RWLOCK *ossl_obj_lock = NULL;
42 #ifdef TSAN_REQUIRES_LOCKING
43 static CRYPTO_RWLOCK *ossl_obj_nid_lock = NULL;
44 #endif
45
46 static CRYPTO_ONCE ossl_obj_lock_init = CRYPTO_ONCE_STATIC_INIT;
47
objs_free_locks(void)48 static ossl_inline void objs_free_locks(void)
49 {
50 CRYPTO_THREAD_lock_free(ossl_obj_lock);
51 ossl_obj_lock = NULL;
52 #ifdef TSAN_REQUIRES_LOCKING
53 CRYPTO_THREAD_lock_free(ossl_obj_nid_lock);
54 ossl_obj_nid_lock = NULL;
55 #endif
56 }
57
DEFINE_RUN_ONCE_STATIC(obj_lock_initialise)58 DEFINE_RUN_ONCE_STATIC(obj_lock_initialise)
59 {
60 ossl_obj_lock = CRYPTO_THREAD_lock_new();
61 if (ossl_obj_lock == NULL)
62 return 0;
63
64 #ifdef TSAN_REQUIRES_LOCKING
65 ossl_obj_nid_lock = CRYPTO_THREAD_lock_new();
66 if (ossl_obj_nid_lock == NULL) {
67 objs_free_locks();
68 return 0;
69 }
70 #endif
71 return 1;
72 }
73
ossl_init_added_lock(void)74 static ossl_inline int ossl_init_added_lock(void)
75 {
76 #ifndef OPENSSL_NO_AUTOLOAD_CONFIG
77 /* Make sure we've loaded config before checking for any "added" objects */
78 OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
79 #endif
80 return RUN_ONCE(&ossl_obj_lock_init, obj_lock_initialise);
81 }
82
ossl_obj_write_lock(int lock)83 static ossl_inline int ossl_obj_write_lock(int lock)
84 {
85 if (!lock)
86 return 1;
87 if (!ossl_init_added_lock())
88 return 0;
89 return CRYPTO_THREAD_write_lock(ossl_obj_lock);
90 }
91
ossl_obj_read_lock(int lock)92 static ossl_inline int ossl_obj_read_lock(int lock)
93 {
94 if (!lock)
95 return 1;
96 if (!ossl_init_added_lock())
97 return 0;
98 return CRYPTO_THREAD_read_lock(ossl_obj_lock);
99 }
100
ossl_obj_unlock(int lock)101 static ossl_inline void ossl_obj_unlock(int lock)
102 {
103 if (lock)
104 CRYPTO_THREAD_unlock(ossl_obj_lock);
105 }
106
sn_cmp(const ASN1_OBJECT * const * a,const unsigned int * b)107 static int sn_cmp(const ASN1_OBJECT *const *a, const unsigned int *b)
108 {
109 return strcmp((*a)->sn, nid_objs[*b].sn);
110 }
111
112 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
113
ln_cmp(const ASN1_OBJECT * const * a,const unsigned int * b)114 static int ln_cmp(const ASN1_OBJECT *const *a, const unsigned int *b)
115 {
116 return strcmp((*a)->ln, nid_objs[*b].ln);
117 }
118
119 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
120
added_obj_hash(const ADDED_OBJ * ca)121 static unsigned long added_obj_hash(const ADDED_OBJ *ca)
122 {
123 const ASN1_OBJECT *a;
124 int i;
125 unsigned long ret = 0;
126 unsigned char *p;
127
128 a = ca->obj;
129 switch (ca->type) {
130 case ADDED_DATA:
131 ret = (unsigned long)a->length << 20UL;
132 p = (unsigned char *)a->data;
133 for (i = 0; i < a->length; i++)
134 ret ^= p[i] << ((i * 3) % 24);
135 break;
136 case ADDED_SNAME:
137 ret = OPENSSL_LH_strhash(a->sn);
138 break;
139 case ADDED_LNAME:
140 ret = OPENSSL_LH_strhash(a->ln);
141 break;
142 case ADDED_NID:
143 ret = a->nid;
144 break;
145 default:
146 /* abort(); */
147 return 0;
148 }
149 ret &= 0x3fffffffL;
150 ret |= ((unsigned long)ca->type) << 30L;
151 return ret;
152 }
153
added_obj_cmp(const ADDED_OBJ * ca,const ADDED_OBJ * cb)154 static int added_obj_cmp(const ADDED_OBJ *ca, const ADDED_OBJ *cb)
155 {
156 ASN1_OBJECT *a, *b;
157 int i;
158
159 i = ca->type - cb->type;
160 if (i)
161 return i;
162 a = ca->obj;
163 b = cb->obj;
164 switch (ca->type) {
165 case ADDED_DATA:
166 i = (a->length - b->length);
167 if (i)
168 return i;
169 return memcmp(a->data, b->data, (size_t)a->length);
170 case ADDED_SNAME:
171 if (a->sn == NULL)
172 return -1;
173 else if (b->sn == NULL)
174 return 1;
175 else
176 return strcmp(a->sn, b->sn);
177 case ADDED_LNAME:
178 if (a->ln == NULL)
179 return -1;
180 else if (b->ln == NULL)
181 return 1;
182 else
183 return strcmp(a->ln, b->ln);
184 case ADDED_NID:
185 return a->nid - b->nid;
186 default:
187 /* abort(); */
188 return 0;
189 }
190 }
191
cleanup1_doall(ADDED_OBJ * a)192 static void cleanup1_doall(ADDED_OBJ *a)
193 {
194 a->obj->nid = 0;
195 a->obj->flags |= ASN1_OBJECT_FLAG_DYNAMIC |
196 ASN1_OBJECT_FLAG_DYNAMIC_STRINGS | ASN1_OBJECT_FLAG_DYNAMIC_DATA;
197 }
198
cleanup2_doall(ADDED_OBJ * a)199 static void cleanup2_doall(ADDED_OBJ *a)
200 {
201 a->obj->nid++;
202 }
203
cleanup3_doall(ADDED_OBJ * a)204 static void cleanup3_doall(ADDED_OBJ *a)
205 {
206 if (--a->obj->nid == 0)
207 ASN1_OBJECT_free(a->obj);
208 OPENSSL_free(a);
209 }
210
ossl_obj_cleanup_int(void)211 void ossl_obj_cleanup_int(void)
212 {
213 if (added != NULL) {
214 lh_ADDED_OBJ_set_down_load(added, 0);
215 lh_ADDED_OBJ_doall(added, cleanup1_doall); /* zero counters */
216 lh_ADDED_OBJ_doall(added, cleanup2_doall); /* set counters */
217 lh_ADDED_OBJ_doall(added, cleanup3_doall); /* free objects */
218 lh_ADDED_OBJ_free(added);
219 added = NULL;
220 }
221 objs_free_locks();
222 }
223
224 /*
225 * Requires that the ossl_obj_lock be held
226 * if TSAN_REQUIRES_LOCKING defined
227 */
obj_new_nid_unlocked(int num)228 static int obj_new_nid_unlocked(int num)
229 {
230 static TSAN_QUALIFIER int new_nid = NUM_NID;
231 #ifdef TSAN_REQUIRES_LOCKING
232 int i;
233
234 i = new_nid;
235 new_nid += num;
236
237 return i;
238 #else
239 return tsan_add(&new_nid, num);
240 #endif
241 }
242
OBJ_new_nid(int num)243 int OBJ_new_nid(int num)
244 {
245 #ifdef TSAN_REQUIRES_LOCKING
246 int i;
247
248 if (!ossl_obj_write_lock(1)) {
249 ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
250 return NID_undef;
251 }
252
253 i = obj_new_nid_unlocked(num);
254
255 ossl_obj_unlock(1);
256
257 return i;
258 #else
259 return obj_new_nid_unlocked(num);
260 #endif
261 }
262
ossl_obj_add_object(const ASN1_OBJECT * obj,int lock)263 static int ossl_obj_add_object(const ASN1_OBJECT *obj, int lock)
264 {
265 ASN1_OBJECT *o = NULL;
266 ADDED_OBJ *ao[4] = { NULL, NULL, NULL, NULL }, *aop;
267 int i;
268
269 if ((o = OBJ_dup(obj)) == NULL)
270 return NID_undef;
271 if ((ao[ADDED_NID] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL
272 || (o->length != 0
273 && obj->data != NULL
274 && (ao[ADDED_DATA] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
275 || (o->sn != NULL
276 && (ao[ADDED_SNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
277 || (o->ln != NULL
278 && (ao[ADDED_LNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL))
279 goto err2;
280
281 if (!ossl_obj_write_lock(lock)) {
282 ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
283 goto err2;
284 }
285 if (added == NULL) {
286 added = lh_ADDED_OBJ_new(added_obj_hash, added_obj_cmp);
287 if (added == NULL) {
288 ERR_raise(ERR_LIB_OBJ, ERR_R_CRYPTO_LIB);
289 goto err;
290 }
291 }
292
293 for (i = ADDED_DATA; i <= ADDED_NID; i++) {
294 if (ao[i] != NULL) {
295 ao[i]->type = i;
296 ao[i]->obj = o;
297 aop = lh_ADDED_OBJ_insert(added, ao[i]);
298 /* memory leak, but should not normally matter */
299 OPENSSL_free(aop);
300 }
301 }
302 o->flags &=
303 ~(ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
304 ASN1_OBJECT_FLAG_DYNAMIC_DATA);
305
306 ossl_obj_unlock(lock);
307 return o->nid;
308
309 err:
310 ossl_obj_unlock(lock);
311 err2:
312 for (i = ADDED_DATA; i <= ADDED_NID; i++)
313 OPENSSL_free(ao[i]);
314 ASN1_OBJECT_free(o);
315 return NID_undef;
316 }
317
OBJ_nid2obj(int n)318 ASN1_OBJECT *OBJ_nid2obj(int n)
319 {
320 ADDED_OBJ ad, *adp = NULL;
321 ASN1_OBJECT ob;
322
323 if (n == NID_undef
324 || (n > 0 && n < NUM_NID && nid_objs[n].nid != NID_undef))
325 return (ASN1_OBJECT *)&(nid_objs[n]);
326
327 ad.type = ADDED_NID;
328 ad.obj = &ob;
329 ob.nid = n;
330 if (!ossl_obj_read_lock(1)) {
331 ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_READ_LOCK);
332 return NULL;
333 }
334 if (added != NULL)
335 adp = lh_ADDED_OBJ_retrieve(added, &ad);
336 ossl_obj_unlock(1);
337 if (adp != NULL)
338 return adp->obj;
339
340 ERR_raise(ERR_LIB_OBJ, OBJ_R_UNKNOWN_NID);
341 return NULL;
342 }
343
OBJ_nid2sn(int n)344 const char *OBJ_nid2sn(int n)
345 {
346 ASN1_OBJECT *ob = OBJ_nid2obj(n);
347
348 return ob == NULL ? NULL : ob->sn;
349 }
350
OBJ_nid2ln(int n)351 const char *OBJ_nid2ln(int n)
352 {
353 ASN1_OBJECT *ob = OBJ_nid2obj(n);
354
355 return ob == NULL ? NULL : ob->ln;
356 }
357
obj_cmp(const ASN1_OBJECT * const * ap,const unsigned int * bp)358 static int obj_cmp(const ASN1_OBJECT *const *ap, const unsigned int *bp)
359 {
360 int j;
361 const ASN1_OBJECT *a = *ap;
362 const ASN1_OBJECT *b = &nid_objs[*bp];
363
364 j = (a->length - b->length);
365 if (j)
366 return j;
367 if (a->length == 0)
368 return 0;
369 return memcmp(a->data, b->data, a->length);
370 }
371
372 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
373
ossl_obj_obj2nid(const ASN1_OBJECT * a,const int lock)374 static int ossl_obj_obj2nid(const ASN1_OBJECT *a, const int lock)
375 {
376 int nid = NID_undef;
377 const unsigned int *op;
378 ADDED_OBJ ad, *adp;
379
380 if (a == NULL)
381 return NID_undef;
382 if (a->nid != NID_undef)
383 return a->nid;
384 if (a->length == 0)
385 return NID_undef;
386
387 op = OBJ_bsearch_obj(&a, obj_objs, NUM_OBJ);
388 if (op != NULL)
389 return nid_objs[*op].nid;
390 if (!ossl_obj_read_lock(lock)) {
391 ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_READ_LOCK);
392 return NID_undef;
393 }
394 if (added != NULL) {
395 ad.type = ADDED_DATA;
396 ad.obj = (ASN1_OBJECT *)a; /* casting away const is harmless here */
397 adp = lh_ADDED_OBJ_retrieve(added, &ad);
398 if (adp != NULL)
399 nid = adp->obj->nid;
400 }
401 ossl_obj_unlock(lock);
402 return nid;
403 }
404
405 /*
406 * Convert an object name into an ASN1_OBJECT if "noname" is not set then
407 * search for short and long names first. This will convert the "dotted" form
408 * into an object: unlike OBJ_txt2nid it can be used with any objects, not
409 * just registered ones.
410 */
OBJ_txt2obj(const char * s,int no_name)411 ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name)
412 {
413 int nid = NID_undef;
414 ASN1_OBJECT *op = NULL;
415 unsigned char *buf;
416 unsigned char *p;
417 const unsigned char *cp;
418 int i, j;
419
420 if (!no_name) {
421 if ((nid = OBJ_sn2nid(s)) != NID_undef
422 || (nid = OBJ_ln2nid(s)) != NID_undef) {
423 return OBJ_nid2obj(nid);
424 }
425 if (!ossl_isdigit(*s)) {
426 ERR_raise(ERR_LIB_OBJ, OBJ_R_UNKNOWN_OBJECT_NAME);
427 return NULL;
428 }
429 }
430
431 /* Work out size of content octets */
432 i = a2d_ASN1_OBJECT(NULL, 0, s, -1);
433 if (i <= 0)
434 return NULL;
435
436 /* Work out total size */
437 j = ASN1_object_size(0, i, V_ASN1_OBJECT);
438 if (j < 0)
439 return NULL;
440
441 if ((buf = OPENSSL_malloc(j)) == NULL)
442 return NULL;
443
444 p = buf;
445 /* Write out tag+length */
446 ASN1_put_object(&p, 0, i, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
447 /* Write out contents */
448 a2d_ASN1_OBJECT(p, i, s, -1);
449
450 cp = buf;
451 op = d2i_ASN1_OBJECT(NULL, &cp, j);
452 OPENSSL_free(buf);
453 return op;
454 }
455
OBJ_obj2txt(char * buf,int buf_len,const ASN1_OBJECT * a,int no_name)456 int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name)
457 {
458 int i, n = 0, len, nid, first, use_bn;
459 BIGNUM *bl;
460 unsigned long l;
461 const unsigned char *p;
462 char tbuf[DECIMAL_SIZE(i) + DECIMAL_SIZE(l) + 2];
463 const char *s;
464
465 /* Ensure that, at every state, |buf| is NUL-terminated. */
466 if (buf != NULL && buf_len > 0)
467 buf[0] = '\0';
468
469 if (a == NULL || a->data == NULL)
470 return 0;
471
472 if (!no_name && (nid = OBJ_obj2nid(a)) != NID_undef) {
473 s = OBJ_nid2ln(nid);
474 if (s == NULL)
475 s = OBJ_nid2sn(nid);
476 if (s != NULL) {
477 if (buf != NULL)
478 OPENSSL_strlcpy(buf, s, buf_len);
479 return (int)strlen(s);
480 }
481 }
482
483 len = a->length;
484 p = a->data;
485
486 first = 1;
487 bl = NULL;
488
489 /*
490 * RFC 2578 (STD 58) says this about OBJECT IDENTIFIERs:
491 *
492 * > 3.5. OBJECT IDENTIFIER values
493 * >
494 * > An OBJECT IDENTIFIER value is an ordered list of non-negative
495 * > numbers. For the SMIv2, each number in the list is referred to as a
496 * > sub-identifier, there are at most 128 sub-identifiers in a value,
497 * > and each sub-identifier has a maximum value of 2^32-1 (4294967295
498 * > decimal).
499 *
500 * So a legitimate OID according to this RFC is at most (32 * 128 / 7),
501 * i.e. 586 bytes long.
502 *
503 * Ref: https://datatracker.ietf.org/doc/html/rfc2578#section-3.5
504 */
505 if (len > 586)
506 goto err;
507
508 while (len > 0) {
509 l = 0;
510 use_bn = 0;
511 for (;;) {
512 unsigned char c = *p++;
513
514 len--;
515 if (len == 0 && (c & 0x80) != 0)
516 goto err;
517 if (use_bn) {
518 if (!BN_add_word(bl, c & 0x7f))
519 goto err;
520 } else {
521 l |= c & 0x7f;
522 }
523 if ((c & 0x80) == 0)
524 break;
525 if (!use_bn && l > (ULONG_MAX >> 7L)) {
526 if (bl == NULL && (bl = BN_new()) == NULL)
527 goto err;
528 if (!BN_set_word(bl, l))
529 goto err;
530 use_bn = 1;
531 }
532 if (use_bn) {
533 if (!BN_lshift(bl, bl, 7))
534 goto err;
535 } else {
536 l <<= 7L;
537 }
538 }
539
540 if (first) {
541 first = 0;
542 if (l >= 80) {
543 i = 2;
544 if (use_bn) {
545 if (!BN_sub_word(bl, 80))
546 goto err;
547 } else {
548 l -= 80;
549 }
550 } else {
551 i = (int)(l / 40);
552 l -= (long)(i * 40);
553 }
554 if (buf != NULL && buf_len > 1) {
555 *buf++ = i + '0';
556 *buf = '\0';
557 buf_len--;
558 }
559 n++;
560 }
561
562 if (use_bn) {
563 char *bndec;
564 bndec = BN_bn2dec(bl);
565 if (!bndec)
566 goto err;
567 i = strlen(bndec);
568 if (buf != NULL) {
569 if (buf_len > 1) {
570 *buf++ = '.';
571 *buf = '\0';
572 buf_len--;
573 }
574 OPENSSL_strlcpy(buf, bndec, buf_len);
575 if (i > buf_len) {
576 buf += buf_len;
577 buf_len = 0;
578 } else {
579 buf += i;
580 buf_len -= i;
581 }
582 }
583 n++;
584 n += i;
585 OPENSSL_free(bndec);
586 } else {
587 BIO_snprintf(tbuf, sizeof(tbuf), ".%lu", l);
588 i = strlen(tbuf);
589 if (buf && buf_len > 0) {
590 OPENSSL_strlcpy(buf, tbuf, buf_len);
591 if (i > buf_len) {
592 buf += buf_len;
593 buf_len = 0;
594 } else {
595 buf += i;
596 buf_len -= i;
597 }
598 }
599 n += i;
600 l = 0;
601 }
602 }
603
604 BN_free(bl);
605 return n;
606
607 err:
608 BN_free(bl);
609 return -1;
610 }
611
OBJ_txt2nid(const char * s)612 int OBJ_txt2nid(const char *s)
613 {
614 ASN1_OBJECT *obj = OBJ_txt2obj(s, 0);
615 int nid = NID_undef;
616
617 if (obj != NULL) {
618 nid = OBJ_obj2nid(obj);
619 ASN1_OBJECT_free(obj);
620 }
621 return nid;
622 }
623
OBJ_ln2nid(const char * s)624 int OBJ_ln2nid(const char *s)
625 {
626 ASN1_OBJECT o;
627 const ASN1_OBJECT *oo = &o;
628 ADDED_OBJ ad, *adp;
629 const unsigned int *op;
630 int nid = NID_undef;
631
632 o.ln = s;
633 op = OBJ_bsearch_ln(&oo, ln_objs, NUM_LN);
634 if (op != NULL)
635 return nid_objs[*op].nid;
636 if (!ossl_obj_read_lock(1)) {
637 ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_READ_LOCK);
638 return NID_undef;
639 }
640 if (added != NULL) {
641 ad.type = ADDED_LNAME;
642 ad.obj = &o;
643 adp = lh_ADDED_OBJ_retrieve(added, &ad);
644 if (adp != NULL)
645 nid = adp->obj->nid;
646 }
647 ossl_obj_unlock(1);
648 return nid;
649 }
650
OBJ_sn2nid(const char * s)651 int OBJ_sn2nid(const char *s)
652 {
653 ASN1_OBJECT o;
654 const ASN1_OBJECT *oo = &o;
655 ADDED_OBJ ad, *adp;
656 const unsigned int *op;
657 int nid = NID_undef;
658
659 o.sn = s;
660 op = OBJ_bsearch_sn(&oo, sn_objs, NUM_SN);
661 if (op != NULL)
662 return nid_objs[*op].nid;
663 if (!ossl_obj_read_lock(1)) {
664 ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_READ_LOCK);
665 return NID_undef;
666 }
667 if (added != NULL) {
668 ad.type = ADDED_SNAME;
669 ad.obj = &o;
670 adp = lh_ADDED_OBJ_retrieve(added, &ad);
671 if (adp != NULL)
672 nid = adp->obj->nid;
673 }
674 ossl_obj_unlock(1);
675 return nid;
676 }
677
OBJ_bsearch_(const void * key,const void * base,int num,int size,int (* cmp)(const void *,const void *))678 const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
679 int (*cmp) (const void *, const void *))
680 {
681 return OBJ_bsearch_ex_(key, base, num, size, cmp, 0);
682 }
683
OBJ_bsearch_ex_(const void * key,const void * base,int num,int size,int (* cmp)(const void *,const void *),int flags)684 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 const char *p = ossl_bsearch(key, base, num, size, cmp, flags);
690
691 #ifdef CHARSET_EBCDIC
692 /*
693 * THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and I
694 * don't have perl (yet), we revert to a *LINEAR* search when the object
695 * wasn't found in the binary search.
696 */
697 if (p == NULL) {
698 const char *base_ = base;
699 int l, h, i = 0, c = 0;
700 char *p1;
701
702 for (i = 0; i < num; ++i) {
703 p1 = &(base_[i * size]);
704 c = (*cmp) (key, p1);
705 if (c == 0
706 || (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)))
707 return p1;
708 }
709 }
710 #endif
711 return p;
712 }
713
714 /*
715 * Parse a BIO sink to create some extra oid's objects.
716 * Line format:<OID:isdigit or '.']><isspace><SN><isspace><LN>
717 */
OBJ_create_objects(BIO * in)718 int OBJ_create_objects(BIO *in)
719 {
720 char buf[512];
721 int i, num = 0;
722 char *o, *s, *l = NULL;
723
724 for (;;) {
725 s = o = NULL;
726 i = BIO_gets(in, buf, 512);
727 if (i <= 0)
728 return num;
729 buf[i - 1] = '\0';
730 if (!ossl_isalnum(buf[0]))
731 return num;
732 o = s = buf;
733 while (ossl_isdigit(*s) || *s == '.')
734 s++;
735 if (*s != '\0') {
736 *(s++) = '\0';
737 while (ossl_isspace(*s))
738 s++;
739 if (*s == '\0') {
740 s = NULL;
741 } else {
742 l = s;
743 while (*l != '\0' && !ossl_isspace(*l))
744 l++;
745 if (*l != '\0') {
746 *(l++) = '\0';
747 while (ossl_isspace(*l))
748 l++;
749 if (*l == '\0') {
750 l = NULL;
751 }
752 } else {
753 l = NULL;
754 }
755 }
756 } else {
757 s = NULL;
758 }
759 if (*o == '\0')
760 return num;
761 if (!OBJ_create(o, s, l))
762 return num;
763 num++;
764 }
765 }
766
OBJ_create(const char * oid,const char * sn,const char * ln)767 int OBJ_create(const char *oid, const char *sn, const char *ln)
768 {
769 ASN1_OBJECT *tmpoid = NULL;
770 int ok = 0;
771
772 /* With no arguments at all, nothing can be done */
773 if (oid == NULL && sn == NULL && ln == NULL) {
774 ERR_raise(ERR_LIB_OBJ, ERR_R_PASSED_INVALID_ARGUMENT);
775 return 0;
776 }
777
778 /* Check to see if short or long name already present */
779 if ((sn != NULL && OBJ_sn2nid(sn) != NID_undef)
780 || (ln != NULL && OBJ_ln2nid(ln) != NID_undef)) {
781 ERR_raise(ERR_LIB_OBJ, OBJ_R_OID_EXISTS);
782 return 0;
783 }
784
785 if (oid != NULL) {
786 /* Convert numerical OID string to an ASN1_OBJECT structure */
787 tmpoid = OBJ_txt2obj(oid, 1);
788 if (tmpoid == NULL)
789 return 0;
790 } else {
791 /* Create a no-OID ASN1_OBJECT */
792 tmpoid = ASN1_OBJECT_new();
793 if (tmpoid == NULL) {
794 ERR_raise(ERR_LIB_OBJ, ERR_R_ASN1_LIB);
795 return 0;
796 }
797 }
798
799 if (!ossl_obj_write_lock(1)) {
800 ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
801 ASN1_OBJECT_free(tmpoid);
802 return 0;
803 }
804
805 /* If NID is not NID_undef then object already exists */
806 if (oid != NULL
807 && ossl_obj_obj2nid(tmpoid, 0) != NID_undef) {
808 ERR_raise(ERR_LIB_OBJ, OBJ_R_OID_EXISTS);
809 goto err;
810 }
811
812 tmpoid->nid = obj_new_nid_unlocked(1);
813
814 if (tmpoid->nid == NID_undef)
815 goto err;
816
817 tmpoid->sn = (char *)sn;
818 tmpoid->ln = (char *)ln;
819
820 ok = ossl_obj_add_object(tmpoid, 0);
821
822 tmpoid->sn = NULL;
823 tmpoid->ln = NULL;
824
825 err:
826 ossl_obj_unlock(1);
827 ASN1_OBJECT_free(tmpoid);
828 return ok;
829 }
830
OBJ_length(const ASN1_OBJECT * obj)831 size_t OBJ_length(const ASN1_OBJECT *obj)
832 {
833 if (obj == NULL)
834 return 0;
835 return obj->length;
836 }
837
OBJ_get0_data(const ASN1_OBJECT * obj)838 const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj)
839 {
840 if (obj == NULL)
841 return NULL;
842 return obj->data;
843 }
844
OBJ_add_object(const ASN1_OBJECT * obj)845 int OBJ_add_object(const ASN1_OBJECT *obj)
846 {
847 return ossl_obj_add_object(obj, 1);
848 }
849
OBJ_obj2nid(const ASN1_OBJECT * a)850 int OBJ_obj2nid(const ASN1_OBJECT *a)
851 {
852 return ossl_obj_obj2nid(a, 1);
853 }
854
