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 "internal/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 /*
 636  * Parse a BIO sink to create some extra oid's objects.
 637  * Line format:<OID:isdigit or '.']><isspace><SN><isspace><LN>
 638  */
 639 int OBJ_create_objects(BIO *in)
 640 {
 641     char buf[512];
 642     int i, num = 0;
 643     char *o, *s, *l = NULL;
 644
 645     for (;;) {
 646         s = o = NULL;
 647         i = BIO_gets(in, buf, 512);
 648         if (i <= 0)
 649             return num;
 650         buf[i - 1] = '\0';
 651         if (!ossl_isalnum(buf[0]))
 652             return num;
 653         o = s = buf;
 654         while (ossl_isdigit(*s) || *s == '.')
 655             s++;
 656         if (*s != '\0') {
 657             *(s++) = '\0';
 658             while (ossl_isspace(*s))
 659                 s++;
 660             if (*s == '\0') {
 661                 s = NULL;
 662             } else {
 663                 l = s;
 664                 while (*l != '\0' && !ossl_isspace(*l))
 665                     l++;
 666                 if (*l != '\0') {
 667                     *(l++) = '\0';
 668                     while (ossl_isspace(*l))
 669                         l++;
 670                     if (*l == '\0') {
 671                         l = NULL;
 672                     }
 673                 } else {
 674                     l = NULL;
 675                 }
 676             }
 677         } else {
 678             s = NULL;
 679         }
 680         if (*o == '\0')
 681             return num;
 682         if (!OBJ_create(o, s, l))
 683             return num;
 684         num++;
 685     }
 686 }
 687
 688 int OBJ_create(const char *oid, const char *sn, const char *ln)
 689 {
 690     ASN1_OBJECT *tmpoid = NULL;
 691     int ok = 0;
 692
 693     /* Check to see if short or long name already present */
 694     if ((sn != NULL && OBJ_sn2nid(sn) != NID_undef)
 695             || (ln != NULL && OBJ_ln2nid(ln) != NID_undef)) {
 696         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
 697         return 0;
 698     }
 699
 700     /* Convert numerical OID string to an ASN1_OBJECT structure */
 701     tmpoid = OBJ_txt2obj(oid, 1);
 702     if (tmpoid == NULL)
 703         return 0;
 704
 705     /* If NID is not NID_undef then object already exists */
 706     if (OBJ_obj2nid(tmpoid) != NID_undef) {
 707         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
 708         goto err;
 709     }
 710
 711     tmpoid->nid = OBJ_new_nid(1);
 712     tmpoid->sn = (char *)sn;
 713     tmpoid->ln = (char *)ln;
 714
 715     ok = OBJ_add_object(tmpoid);
 716
 717     tmpoid->sn = NULL;
 718     tmpoid->ln = NULL;
 719
 720  err:
 721     ASN1_OBJECT_free(tmpoid);
 722     return ok;
 723 }
 724
 725 size_t OBJ_length(const ASN1_OBJECT *obj)
 726 {
 727     if (obj == NULL)
 728         return 0;
 729     return obj->length;
 730 }
 731
 732 const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj)
 733 {
 734     if (obj == NULL)
 735         return NULL;
 736     return obj->data;
 737 }