crypto/objects/obj_dat.c

   1 /*
   2  * Copyright 1995-2016 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, buit 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
 377     if ((buf = OPENSSL_malloc(j)) == NULL)
 378         return NULL;
 379
 380     p = buf;
 381     /* Write out tag+length */
 382     ASN1_put_object(&p, 0, i, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
 383     /* Write out contents */
 384     a2d_ASN1_OBJECT(p, i, s, -1);
 385
 386     cp = buf;
 387     op = d2i_ASN1_OBJECT(NULL, &cp, j);
 388     OPENSSL_free(buf);
 389     return op;
 390 }
 391
 392 int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name)
 393 {
 394     int i, n = 0, len, nid, first, use_bn;
 395     BIGNUM *bl;
 396     unsigned long l;
 397     const unsigned char *p;
 398     char tbuf[DECIMAL_SIZE(i) + DECIMAL_SIZE(l) + 2];
 399
 400     /* Ensure that, at every state, |buf| is NUL-terminated. */
 401     if (buf && buf_len > 0)
 402         buf[0] = '\0';
 403
 404     if ((a == NULL) || (a->data == NULL))
 405         return (0);
 406
 407     if (!no_name && (nid = OBJ_obj2nid(a)) != NID_undef) {
 408         const char *s;
 409         s = OBJ_nid2ln(nid);
 410         if (s == NULL)
 411             s = OBJ_nid2sn(nid);
 412         if (s) {
 413             if (buf)
 414                 OPENSSL_strlcpy(buf, s, buf_len);
 415             n = strlen(s);
 416             return n;
 417         }
 418     }
 419
 420     len = a->length;
 421     p = a->data;
 422
 423     first = 1;
 424     bl = NULL;
 425
 426     while (len > 0) {
 427         l = 0;
 428         use_bn = 0;
 429         for (;;) {
 430             unsigned char c = *p++;
 431             len--;
 432             if ((len == 0) && (c & 0x80))
 433                 goto err;
 434             if (use_bn) {
 435                 if (!BN_add_word(bl, c & 0x7f))
 436                     goto err;
 437             } else
 438                 l |= c & 0x7f;
 439             if (!(c & 0x80))
 440                 break;
 441             if (!use_bn && (l > (ULONG_MAX >> 7L))) {
 442                 if (bl == NULL && (bl = BN_new()) == NULL)
 443                     goto err;
 444                 if (!BN_set_word(bl, l))
 445                     goto err;
 446                 use_bn = 1;
 447             }
 448             if (use_bn) {
 449                 if (!BN_lshift(bl, bl, 7))
 450                     goto err;
 451             } else
 452                 l <<= 7L;
 453         }
 454
 455         if (first) {
 456             first = 0;
 457             if (l >= 80) {
 458                 i = 2;
 459                 if (use_bn) {
 460                     if (!BN_sub_word(bl, 80))
 461                         goto err;
 462                 } else
 463                     l -= 80;
 464             } else {
 465                 i = (int)(l / 40);
 466                 l -= (long)(i * 40);
 467             }
 468             if (buf && (buf_len > 1)) {
 469                 *buf++ = i + '0';
 470                 *buf = '\0';
 471                 buf_len--;
 472             }
 473             n++;
 474         }
 475
 476         if (use_bn) {
 477             char *bndec;
 478             bndec = BN_bn2dec(bl);
 479             if (!bndec)
 480                 goto err;
 481             i = strlen(bndec);
 482             if (buf) {
 483                 if (buf_len > 1) {
 484                     *buf++ = '.';
 485                     *buf = '\0';
 486                     buf_len--;
 487                 }
 488                 OPENSSL_strlcpy(buf, bndec, buf_len);
 489                 if (i > buf_len) {
 490                     buf += buf_len;
 491                     buf_len = 0;
 492                 } else {
 493                     buf += i;
 494                     buf_len -= i;
 495                 }
 496             }
 497             n++;
 498             n += i;
 499             OPENSSL_free(bndec);
 500         } else {
 501             BIO_snprintf(tbuf, sizeof tbuf, ".%lu", l);
 502             i = strlen(tbuf);
 503             if (buf && (buf_len > 0)) {
 504                 OPENSSL_strlcpy(buf, tbuf, buf_len);
 505                 if (i > buf_len) {
 506                     buf += buf_len;
 507                     buf_len = 0;
 508                 } else {
 509                     buf += i;
 510                     buf_len -= i;
 511                 }
 512             }
 513             n += i;
 514             l = 0;
 515         }
 516     }
 517
 518     BN_free(bl);
 519     return n;
 520
 521  err:
 522     BN_free(bl);
 523     return -1;
 524 }
 525
 526 int OBJ_txt2nid(const char *s)
 527 {
 528     ASN1_OBJECT *obj;
 529     int nid;
 530     obj = OBJ_txt2obj(s, 0);
 531     nid = OBJ_obj2nid(obj);
 532     ASN1_OBJECT_free(obj);
 533     return nid;
 534 }
 535
 536 int OBJ_ln2nid(const char *s)
 537 {
 538     ASN1_OBJECT o;
 539     const ASN1_OBJECT *oo = &o;
 540     ADDED_OBJ ad, *adp;
 541     const unsigned int *op;
 542
 543     o.ln = s;
 544     if (added != NULL) {
 545         ad.type = ADDED_LNAME;
 546         ad.obj = &o;
 547         adp = lh_ADDED_OBJ_retrieve(added, &ad);
 548         if (adp != NULL)
 549             return (adp->obj->nid);
 550     }
 551     op = OBJ_bsearch_ln(&oo, ln_objs, NUM_LN);
 552     if (op == NULL)
 553         return (NID_undef);
 554     return (nid_objs[*op].nid);
 555 }
 556
 557 int OBJ_sn2nid(const char *s)
 558 {
 559     ASN1_OBJECT o;
 560     const ASN1_OBJECT *oo = &o;
 561     ADDED_OBJ ad, *adp;
 562     const unsigned int *op;
 563
 564     o.sn = s;
 565     if (added != NULL) {
 566         ad.type = ADDED_SNAME;
 567         ad.obj = &o;
 568         adp = lh_ADDED_OBJ_retrieve(added, &ad);
 569         if (adp != NULL)
 570             return (adp->obj->nid);
 571     }
 572     op = OBJ_bsearch_sn(&oo, sn_objs, NUM_SN);
 573     if (op == NULL)
 574         return (NID_undef);
 575     return (nid_objs[*op].nid);
 576 }
 577
 578 const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
 579                          int (*cmp) (const void *, const void *))
 580 {
 581     return OBJ_bsearch_ex_(key, base, num, size, cmp, 0);
 582 }
 583
 584 const void *OBJ_bsearch_ex_(const void *key, const void *base_, int num,
 585                             int size,
 586                             int (*cmp) (const void *, const void *),
 587                             int flags)
 588 {
 589     const char *base = base_;
 590     int l, h, i = 0, c = 0;
 591     const char *p = NULL;
 592
 593     if (num == 0)
 594         return (NULL);
 595     l = 0;
 596     h = num;
 597     while (l < h) {
 598         i = (l + h) / 2;
 599         p = &(base[i * size]);
 600         c = (*cmp) (key, p);
 601         if (c < 0)
 602             h = i;
 603         else if (c > 0)
 604             l = i + 1;
 605         else
 606             break;
 607     }
 608 #ifdef CHARSET_EBCDIC
 609     /*
 610      * THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and I
 611      * don't have perl (yet), we revert to a *LINEAR* search when the object
 612      * wasn't found in the binary search.
 613      */
 614     if (c != 0) {
 615         for (i = 0; i < num; ++i) {
 616             p = &(base[i * size]);
 617             c = (*cmp) (key, p);
 618             if (c == 0 || (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)))
 619                 return p;
 620         }
 621     }
 622 #endif
 623     if (c != 0 && !(flags & OBJ_BSEARCH_VALUE_ON_NOMATCH))
 624         p = NULL;
 625     else if (c == 0 && (flags & OBJ_BSEARCH_FIRST_VALUE_ON_MATCH)) {
 626         while (i > 0 && (*cmp) (key, &(base[(i - 1) * size])) == 0)
 627             i--;
 628         p = &(base[i * size]);
 629     }
 630     return (p);
 631 }
 632
 633 int OBJ_create_objects(BIO *in)
 634 {
 635     char buf[512];
 636     int i, num = 0;
 637     char *o, *s, *l = NULL;
 638
 639     for (;;) {
 640         s = o = NULL;
 641         i = BIO_gets(in, buf, 512);
 642         if (i <= 0)
 643             return (num);
 644         buf[i - 1] = '\0';
 645         if (!isalnum((unsigned char)buf[0]))
 646             return (num);
 647         o = s = buf;
 648         while (isdigit((unsigned char)*s) || (*s == '.'))
 649             s++;
 650         if (*s != '\0') {
 651             *(s++) = '\0';
 652             while (isspace((unsigned char)*s))
 653                 s++;
 654             if (*s == '\0')
 655                 s = NULL;
 656             else {
 657                 l = s;
 658                 while ((*l != '\0') && !isspace((unsigned char)*l))
 659                     l++;
 660                 if (*l != '\0') {
 661                     *(l++) = '\0';
 662                     while (isspace((unsigned char)*l))
 663                         l++;
 664                     if (*l == '\0')
 665                         l = NULL;
 666                 } else
 667                     l = NULL;
 668             }
 669         } else
 670             s = NULL;
 671         if ((o == NULL) || (*o == '\0'))
 672             return (num);
 673         if (!OBJ_create(o, s, l))
 674             return (num);
 675         num++;
 676     }
 677     /* return(num); */
 678 }
 679
 680 int OBJ_create(const char *oid, const char *sn, const char *ln)
 681 {
 682     ASN1_OBJECT *tmpoid = NULL;
 683     int ok = 0;
 684
 685     /* Check to see if short or long name already present */
 686     if (OBJ_sn2nid(sn) != NID_undef || OBJ_ln2nid(ln) != NID_undef) {
 687         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
 688         return 0;
 689     }
 690
 691     /* Convert numerical OID string to an ASN1_OBJECT structure */
 692     tmpoid = OBJ_txt2obj(oid, 1);
 693
 694     /* If NID is not NID_undef then object already exists */
 695     if (OBJ_obj2nid(tmpoid) != NID_undef) {
 696         OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
 697         goto err;
 698     }
 699
 700     tmpoid->nid = OBJ_new_nid(1);
 701     tmpoid->sn = (char *)sn;
 702     tmpoid->ln = (char *)ln;
 703
 704     ok = OBJ_add_object(tmpoid);
 705
 706     tmpoid->sn = NULL;
 707     tmpoid->ln = NULL;
 708
 709  err:
 710     ASN1_OBJECT_free(tmpoid);
 711     return ok;
 712 }
 713
 714 size_t OBJ_length(const ASN1_OBJECT *obj)
 715 {
 716     if (obj == NULL)
 717         return 0;
 718     return obj->length;
 719 }
 720
 721 const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj)
 722 {
 723     if (obj == NULL)
 724         return NULL;
 725     return obj->data;
 726 }