crypto/objects/obj_dat.c

   1 /*
   2  * Copyright 1995-2018 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 <openssl/lhash.h>
  15 #include <openssl/asn1.h>
  16 #include "crypto/objects.h"
  17 #include <openssl/bn.h>
  18 #include "crypto/asn1.h"
  19 #include "obj_local.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     ASN1_OBJECT_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     }
 232
 233     /* Make sure we've loaded config before checking for any "added" objects */
 234     OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
 235
 236     if (added == NULL)
 237         return NULL;
 238
 239     ad.type = ADDED_NID;
 240     ad.obj = &ob;
 241     ob.nid = n;
 242     adp = lh_ADDED_OBJ_retrieve(added, &ad);
 243     if (adp != NULL)
 244         return adp->obj;
 245
 246     OBJerr(OBJ_F_OBJ_NID2OBJ, OBJ_R_UNKNOWN_NID);
 247     return NULL;
 248 }
 249
 250 const char *OBJ_nid2sn(int n)
 251 {
 252     ADDED_OBJ ad, *adp;
 253     ASN1_OBJECT ob;
 254
 255     if ((n >= 0) && (n < NUM_NID)) {
 256         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
 257             OBJerr(OBJ_F_OBJ_NID2SN, OBJ_R_UNKNOWN_NID);
 258             return NULL;
 259         }
 260         return nid_objs[n].sn;
 261     }
 262
 263     /* Make sure we've loaded config before checking for any "added" objects */
 264     OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
 265
 266     if (added == NULL)
 267         return NULL;
 268
 269     ad.type = ADDED_NID;
 270     ad.obj = &ob;
 271     ob.nid = n;
 272     adp = lh_ADDED_OBJ_retrieve(added, &ad);
 273     if (adp != NULL)
 274         return adp->obj->sn;
 275
 276     OBJerr(OBJ_F_OBJ_NID2SN, OBJ_R_UNKNOWN_NID);
 277     return NULL;
 278 }
 279
 280 const char *OBJ_nid2ln(int n)
 281 {
 282     ADDED_OBJ ad, *adp;
 283     ASN1_OBJECT ob;
 284
 285     if ((n >= 0) && (n < NUM_NID)) {
 286         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
 287             OBJerr(OBJ_F_OBJ_NID2LN, OBJ_R_UNKNOWN_NID);
 288             return NULL;
 289         }
 290         return nid_objs[n].ln;
 291     }
 292
 293     /* Make sure we've loaded config before checking for any "added" objects */
 294     OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
 295
 296     if (added == NULL)
 297         return NULL;
 298
 299     ad.type = ADDED_NID;
 300     ad.obj = &ob;
 301     ob.nid = n;
 302     adp = lh_ADDED_OBJ_retrieve(added, &ad);
 303     if (adp != NULL)
 304         return adp->obj->ln;
 305
 306     OBJerr(OBJ_F_OBJ_NID2LN, OBJ_R_UNKNOWN_NID);
 307     return NULL;
 308 }
 309
 310 static int obj_cmp(const ASN1_OBJECT *const *ap, const unsigned int *bp)
 311 {
 312     int j;
 313     const ASN1_OBJECT *a = *ap;
 314     const ASN1_OBJECT *b = &nid_objs[*bp];
 315
 316     j = (a->length - b->length);
 317     if (j)
 318         return j;
 319     if (a->length == 0)
 320         return 0;
 321     return memcmp(a->data, b->data, a->length);
 322 }
 323
 324 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
 325
 326 int OBJ_obj2nid(const ASN1_OBJECT *a)
 327 {
 328     const unsigned int *op;
 329     ADDED_OBJ ad, *adp;
 330
 331     if (a == NULL)
 332         return NID_undef;
 333     if (a->nid != 0)
 334         return a->nid;
 335
 336     if (a->length == 0)
 337         return NID_undef;
 338
 339     /* Make sure we've loaded config before checking for any "added" objects */
 340     OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
 341
 342     if (added != NULL) {
 343         ad.type = ADDED_DATA;
 344         ad.obj = (ASN1_OBJECT *)a; /* XXX: ugly but harmless */
 345         adp = lh_ADDED_OBJ_retrieve(added, &ad);
 346         if (adp != NULL)
 347             return adp->obj->nid;
 348     }
 349     op = OBJ_bsearch_obj(&a, obj_objs, NUM_OBJ);
 350     if (op == NULL)
 351         return NID_undef;
 352     return nid_objs[*op].nid;
 353 }
 354
 355 /*
 356  * Convert an object name into an ASN1_OBJECT if "noname" is not set then
 357  * search for short and long names first. This will convert the "dotted" form
 358  * into an object: unlike OBJ_txt2nid it can be used with any objects, not
 359  * just registered ones.
 360  */
 361
 362 ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name)
 363 {
 364     int nid = NID_undef;
 365     ASN1_OBJECT *op;
 366     unsigned char *buf;
 367     unsigned char *p;
 368     const unsigned char *cp;
 369     int i, j;
 370
 371     if (!no_name) {
 372         if (((nid = OBJ_sn2nid(s)) != NID_undef) ||
 373             ((nid = OBJ_ln2nid(s)) != NID_undef))
 374             return OBJ_nid2obj(nid);
 375         if (!ossl_isdigit(*s)) {
 376             OBJerr(OBJ_F_OBJ_TXT2OBJ, OBJ_R_UNKNOWN_OBJECT_NAME);
 377             return NULL;
 378         }
 379     }
 380
 381     /* Work out size of content octets */
 382     i = a2d_ASN1_OBJECT(NULL, 0, s, -1);
 383     if (i <= 0) {
 384         /* Don't clear the error */
 385         /*
 386          * ERR_clear_error();
 387          */
 388         return NULL;
 389     }
 390     /* Work out total size */
 391     j = ASN1_object_size(0, i, V_ASN1_OBJECT);
 392     if (j < 0)
 393         return NULL;
 394
 395     if ((buf = OPENSSL_malloc(j)) == NULL) {
 396         OBJerr(OBJ_F_OBJ_TXT2OBJ, ERR_R_MALLOC_FAILURE);
 397         return NULL;
 398     }
 399
 400     p = buf;
 401     /* Write out tag+length */
 402     ASN1_put_object(&p, 0, i, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
 403     /* Write out contents */
 404     a2d_ASN1_OBJECT(p, i, s, -1);
 405
 406     cp = buf;
 407     op = d2i_ASN1_OBJECT(NULL, &cp, j);
 408     OPENSSL_free(buf);
 409     return op;
 410 }
 411
 412 int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name)
 413 {
 414     int i, n = 0, len, nid, first, use_bn;
 415     BIGNUM *bl;
 416     unsigned long l;
 417     const unsigned char *p;
 418     char tbuf[DECIMAL_SIZE(i) + DECIMAL_SIZE(l) + 2];
 419
 420     /* Ensure that, at every state, |buf| is NUL-terminated. */
 421     if (buf && buf_len > 0)
 422         buf[0] = '\0';
 423
 424     if ((a == NULL) || (a->data == NULL))
 425         return 0;
 426
 427     if (!no_name && (nid = OBJ_obj2nid(a)) != NID_undef) {
 428         const char *s;
 429         s = OBJ_nid2ln(nid);
 430         if (s == NULL)
 431             s = OBJ_nid2sn(nid);
 432         if (s) {
 433             if (buf)
 434                 OPENSSL_strlcpy(buf, s, buf_len);
 435             n = strlen(s);
 436             return n;
 437         }
 438     }
 439
 440     len = a->length;
 441     p = a->data;
 442
 443     first = 1;
 444     bl = NULL;
 445
 446     while (len > 0) {
 447         l = 0;
 448         use_bn = 0;
 449         for (;;) {
 450             unsigned char c = *p++;
 451             len--;
 452             if ((len == 0) && (c & 0x80))
 453                 goto err;
 454             if (use_bn) {
 455                 if (!BN_add_word(bl, c & 0x7f))
 456                     goto err;
 457             } else
 458                 l |= c & 0x7f;
 459             if (!(c & 0x80))
 460                 break;
 461             if (!use_bn && (l > (ULONG_MAX >> 7L))) {
 462                 if (bl == NULL && (bl = BN_new()) == NULL)
 463                     goto err;
 464                 if (!BN_set_word(bl, l))
 465                     goto err;
 466                 use_bn = 1;
 467             }
 468             if (use_bn) {
 469                 if (!BN_lshift(bl, bl, 7))
 470                     goto err;
 471             } else
 472                 l <<= 7L;
 473         }
 474
 475         if (first) {
 476             first = 0;
 477             if (l >= 80) {
 478                 i = 2;
 479                 if (use_bn) {
 480                     if (!BN_sub_word(bl, 80))
 481                         goto err;
 482                 } else
 483                     l -= 80;
 484             } else {
 485                 i = (int)(l / 40);
 486                 l -= (long)(i * 40);
 487             }
 488             if (buf && (buf_len > 1)) {
 489                 *buf++ = i + '0';
 490                 *buf = '\0';
 491                 buf_len--;
 492             }
 493             n++;
 494         }
 495
 496         if (use_bn) {
 497             char *bndec;
 498             bndec = BN_bn2dec(bl);
 499             if (!bndec)
 500                 goto err;
 501             i = strlen(bndec);
 502             if (buf) {
 503                 if (buf_len > 1) {
 504                     *buf++ = '.';
 505                     *buf = '\0';
 506                     buf_len--;
 507                 }
 508                 OPENSSL_strlcpy(buf, bndec, buf_len);
 509                 if (i > buf_len) {
 510                     buf += buf_len;
 511                     buf_len = 0;
 512                 } else {
 513                     buf += i;
 514                     buf_len -= i;
 515                 }
 516             }
 517             n++;
 518             n += i;
 519             OPENSSL_free(bndec);
 520         } else {
 521             BIO_snprintf(tbuf, sizeof(tbuf), ".%lu", l);
 522             i = strlen(tbuf);
 523             if (buf && (buf_len > 0)) {
 524                 OPENSSL_strlcpy(buf, tbuf, buf_len);
 525                 if (i > buf_len) {
 526                     buf += buf_len;
 527                     buf_len = 0;
 528                 } else {
 529                     buf += i;
 530                     buf_len -= i;
 531                 }
 532             }
 533             n += i;
 534             l = 0;
 535         }
 536     }
 537
 538     BN_free(bl);
 539     return n;
 540
 541  err:
 542     BN_free(bl);
 543     return -1;
 544 }
 545
 546 int OBJ_txt2nid(const char *s)
 547 {
 548     ASN1_OBJECT *obj;
 549     int nid;
 550     obj = OBJ_txt2obj(s, 0);
 551     nid = OBJ_obj2nid(obj);
 552     ASN1_OBJECT_free(obj);
 553     return nid;
 554 }
 555
 556 int OBJ_ln2nid(const char *s)
 557 {
 558     ASN1_OBJECT o;
 559     const ASN1_OBJECT *oo = &o;
 560     ADDED_OBJ ad, *adp;
 561     const unsigned int *op;
 562
 563     /* Make sure we've loaded config before checking for any "added" objects */
 564     OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
 565
 566     o.ln = s;
 567     if (added != NULL) {
 568         ad.type = ADDED_LNAME;
 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_ln(&oo, ln_objs, NUM_LN);
 575     if (op == NULL)
 576         return NID_undef;
 577     return nid_objs[*op].nid;
 578 }
 579
 580 int OBJ_sn2nid(const char *s)
 581 {
 582     ASN1_OBJECT o;
 583     const ASN1_OBJECT *oo = &o;
 584     ADDED_OBJ ad, *adp;
 585     const unsigned int *op;
 586
 587     /* Make sure we've loaded config before checking for any "added" objects */
 588     OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
 589
 590     o.sn = s;
 591     if (added != NULL) {
 592         ad.type = ADDED_SNAME;
 593         ad.obj = &o;
 594         adp = lh_ADDED_OBJ_retrieve(added, &ad);
 595         if (adp != NULL)
 596             return adp->obj->nid;
 597     }
 598     op = OBJ_bsearch_sn(&oo, sn_objs, NUM_SN);
 599     if (op == NULL)
 600         return NID_undef;
 601     return nid_objs[*op].nid;
 602 }
 603
 604 const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
 605                          int (*cmp) (const void *, const void *))
 606 {
 607     return OBJ_bsearch_ex_(key, base, num, size, cmp, 0);
 608 }
 609
 610 const void *OBJ_bsearch_ex_(const void *key, const void *base, int num,
 611                             int size,
 612                             int (*cmp) (const void *, const void *),
 613                             int flags)
 614 {
 615     const char *p = ossl_bsearch(key, base, num, size, cmp, flags);
 616
 617 #ifdef CHARSET_EBCDIC
 618     /*
 619      * THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and I
 620      * don't have perl (yet), we revert to a *LINEAR* search when the object
 621      * wasn't found in the binary search.
 622      */
 623     if (p == NULL) {
 624         const char *base_ = base;
 625         int l, h, i = 0, c = 0;
 626
 627         for (i = 0; i < num; ++i) {
 628             p = &(base_[i * size]);
 629             c = (*cmp) (key, p);
 630             if (c == 0
 631                 || (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)))
 632                 return p;
 633         }
 634     }
 635 #endif
 636     return p;
 637 }
 638
 639 /*
 640  * Parse a BIO sink to create some extra oid's objects.
 641  * Line format:<OID:isdigit or '.']><isspace><SN><isspace><LN>
 642  */
 643 int OBJ_create_objects(BIO *in)
 644 {
 645     char buf[512];
 646     int i, num = 0;
 647     char *o, *s, *l = NULL;
 648
 649     for (;;) {
 650         s = o = NULL;
 651         i = BIO_gets(in, buf, 512);
 652         if (i <= 0)
 653             return num;
 654         buf[i - 1] = '\0';
 655         if (!ossl_isalnum(buf[0]))
 656             return num;
 657         o = s = buf;
 658         while (ossl_isdigit(*s) || *s == '.')
 659             s++;
 660         if (*s != '\0') {
 661             *(s++) = '\0';
 662             while (ossl_isspace(*s))
 663                 s++;
 664             if (*s == '\0') {
 665                 s = NULL;
 666             } else {
 667                 l = s;
 668                 while (*l != '\0' && !ossl_isspace(*l))
 669                     l++;
 670                 if (*l != '\0') {
 671                     *(l++) = '\0';
 672                     while (ossl_isspace(*l))
 673                         l++;
 674                     if (*l == '\0') {
 675                         l = NULL;
 676                     }
 677                 } else {
 678                     l = NULL;
 679                 }
 680             }
 681         } else {
 682             s = NULL;
 683         }
 684         if (*o == '\0')
 685             return num;
 686         if (!OBJ_create(o, s, l))
 687             return num;
 688         num++;
 689     }
 690 }
 691
 692 int OBJ_create(const char *oid, const char *sn, const char *ln)
 693 {
 694     ASN1_OBJECT *tmpoid = NULL;
 695     int ok = 0;
 696
 697     /* Check to see if short or long name already present */
 698     if ((sn != NULL && OBJ_sn2nid(sn) != NID_undef)
 699             || (ln != NULL && OBJ_ln2nid(ln) != NID_undef)) {
 700         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
 701         return 0;
 702     }
 703
 704     /* Convert numerical OID string to an ASN1_OBJECT structure */
 705     tmpoid = OBJ_txt2obj(oid, 1);
 706     if (tmpoid == NULL)
 707         return 0;
 708
 709     /* If NID is not NID_undef then object already exists */
 710     if (OBJ_obj2nid(tmpoid) != NID_undef) {
 711         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
 712         goto err;
 713     }
 714
 715     tmpoid->nid = OBJ_new_nid(1);
 716     tmpoid->sn = (char *)sn;
 717     tmpoid->ln = (char *)ln;
 718
 719     ok = OBJ_add_object(tmpoid);
 720
 721     tmpoid->sn = NULL;
 722     tmpoid->ln = NULL;
 723
 724  err:
 725     ASN1_OBJECT_free(tmpoid);
 726     return ok;
 727 }
 728
 729 size_t OBJ_length(const ASN1_OBJECT *obj)
 730 {
 731     if (obj == NULL)
 732         return 0;
 733     return obj->length;
 734 }
 735
 736 const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj)
 737 {
 738     if (obj == NULL)
 739         return NULL;
 740     return obj->data;
 741 }