[331] | 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, 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 | /* return(num); */
|
---|
| 680 | }
|
---|
| 681 |
|
---|
| 682 | int OBJ_create(const char *oid, const char *sn, const char *ln)
|
---|
| 683 | {
|
---|
| 684 | ASN1_OBJECT *tmpoid = NULL;
|
---|
| 685 | int ok = 0;
|
---|
| 686 |
|
---|
| 687 | /* Check to see if short or long name already present */
|
---|
| 688 | if (OBJ_sn2nid(sn) != NID_undef || 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 |
|
---|
| 696 | /* If NID is not NID_undef then object already exists */
|
---|
| 697 | if (OBJ_obj2nid(tmpoid) != NID_undef) {
|
---|
| 698 | OBJerr(OBJ_F_OBJ_CREATE, OBJ_R_OID_EXISTS);
|
---|
| 699 | goto err;
|
---|
| 700 | }
|
---|
| 701 |
|
---|
| 702 | tmpoid->nid = OBJ_new_nid(1);
|
---|
| 703 | tmpoid->sn = (char *)sn;
|
---|
| 704 | tmpoid->ln = (char *)ln;
|
---|
| 705 |
|
---|
| 706 | ok = OBJ_add_object(tmpoid);
|
---|
| 707 |
|
---|
| 708 | tmpoid->sn = NULL;
|
---|
| 709 | tmpoid->ln = NULL;
|
---|
| 710 |
|
---|
| 711 | err:
|
---|
| 712 | ASN1_OBJECT_free(tmpoid);
|
---|
| 713 | return ok;
|
---|
| 714 | }
|
---|
| 715 |
|
---|
| 716 | size_t OBJ_length(const ASN1_OBJECT *obj)
|
---|
| 717 | {
|
---|
| 718 | if (obj == NULL)
|
---|
| 719 | return 0;
|
---|
| 720 | return obj->length;
|
---|
| 721 | }
|
---|
| 722 |
|
---|
| 723 | const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj)
|
---|
| 724 | {
|
---|
| 725 | if (obj == NULL)
|
---|
| 726 | return NULL;
|
---|
| 727 | return obj->data;
|
---|
| 728 | }
|
---|