crypto/x509/v3_alt.c

   1 /*
   2  * Copyright 1999-2017 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 "internal/cryptlib.h"
  12 #include <openssl/conf.h>
  13 #include <openssl/x509v3.h>
  14 #include "ext_dat.h"
  15
  16 DEFINE_STACK_OF(CONF_VALUE)
  17 DEFINE_STACK_OF(GENERAL_NAME)
  18
  19 static GENERAL_NAMES *v2i_subject_alt(X509V3_EXT_METHOD *method,
  20                                       X509V3_CTX *ctx,
  21                                       STACK_OF(CONF_VALUE) *nval);
  22 static GENERAL_NAMES *v2i_issuer_alt(X509V3_EXT_METHOD *method,
  23                                      X509V3_CTX *ctx,
  24                                      STACK_OF(CONF_VALUE) *nval);
  25 static int copy_email(X509V3_CTX *ctx, GENERAL_NAMES *gens, int move_p);
  26 static int copy_issuer(X509V3_CTX *ctx, GENERAL_NAMES *gens);
  27 static int do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx);
  28 static int do_dirname(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx);
  29
  30 const X509V3_EXT_METHOD v3_alt[3] = {
  31     {NID_subject_alt_name, 0, ASN1_ITEM_ref(GENERAL_NAMES),
  32      0, 0, 0, 0,
  33      0, 0,
  34      (X509V3_EXT_I2V) i2v_GENERAL_NAMES,
  35      (X509V3_EXT_V2I)v2i_subject_alt,
  36      NULL, NULL, NULL},
  37
  38     {NID_issuer_alt_name, 0, ASN1_ITEM_ref(GENERAL_NAMES),
  39      0, 0, 0, 0,
  40      0, 0,
  41      (X509V3_EXT_I2V) i2v_GENERAL_NAMES,
  42      (X509V3_EXT_V2I)v2i_issuer_alt,
  43      NULL, NULL, NULL},
  44
  45     {NID_certificate_issuer, 0, ASN1_ITEM_ref(GENERAL_NAMES),
  46      0, 0, 0, 0,
  47      0, 0,
  48      (X509V3_EXT_I2V) i2v_GENERAL_NAMES,
  49      NULL, NULL, NULL, NULL},
  50 };
  51
  52 STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method,
  53                                         GENERAL_NAMES *gens,
  54                                         STACK_OF(CONF_VALUE) *ret)
  55 {
  56     int i;
  57     GENERAL_NAME *gen;
  58     STACK_OF(CONF_VALUE) *tmpret = NULL, *origret = ret;
  59
  60     for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
  61         gen = sk_GENERAL_NAME_value(gens, i);
  62         /*
  63          * i2v_GENERAL_NAME allocates ret if it is NULL. If something goes
  64          * wrong we need to free the stack - but only if it was empty when we
  65          * originally entered this function.
  66          */
  67         tmpret = i2v_GENERAL_NAME(method, gen, ret);
  68         if (tmpret == NULL) {
  69             if (origret == NULL)
  70                 sk_CONF_VALUE_pop_free(ret, X509V3_conf_free);
  71             return NULL;
  72         }
  73         ret = tmpret;
  74     }
  75     if (ret == NULL)
  76         return sk_CONF_VALUE_new_null();
  77     return ret;
  78 }
  79
  80 STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method,
  81                                        GENERAL_NAME *gen,
  82                                        STACK_OF(CONF_VALUE) *ret)
  83 {
  84     unsigned char *p;
  85     char oline[256], htmp[5];
  86     int i;
  87
  88     switch (gen->type) {
  89     case GEN_OTHERNAME:
  90         switch (OBJ_obj2nid(gen->d.otherName->type_id)) {
  91         case NID_id_on_SmtpUTF8Mailbox:
  92             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
  93                     || !X509V3_add_value_uchar("othername: SmtpUTF8Mailbox:",
  94                             gen->d.otherName->value->value.utf8string->data,
  95                             &ret))
  96                 return NULL;
  97             break;
  98         case NID_XmppAddr:
  99             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
 100                     || !X509V3_add_value_uchar("othername: XmppAddr:",
 101                             gen->d.otherName->value->value.utf8string->data,
 102                             &ret))
 103                 return NULL;
 104             break;
 105         case NID_SRVName:
 106             if (gen->d.otherName->value->type != V_ASN1_IA5STRING
 107                     || !X509V3_add_value_uchar("othername: SRVName:",
 108                             gen->d.otherName->value->value.ia5string->data,
 109                             &ret))
 110                 return NULL;
 111             break;
 112         case NID_ms_upn:
 113             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
 114                     || !X509V3_add_value_uchar("othername: UPN:",
 115                             gen->d.otherName->value->value.utf8string->data,
 116                             &ret))
 117                 return NULL;
 118             break;
 119         case NID_NAIRealm:
 120             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
 121                     || !X509V3_add_value_uchar("othername: NAIRealm:",
 122                             gen->d.otherName->value->value.utf8string->data,
 123                             &ret))
 124                 return NULL;
 125             break;
 126         default:
 127             if (!X509V3_add_value("othername", "<unsupported>", &ret))
 128                 return NULL;
 129             break;
 130         }
 131         break;
 132
 133     case GEN_X400:
 134         if (!X509V3_add_value("X400Name", "<unsupported>", &ret))
 135             return NULL;
 136         break;
 137
 138     case GEN_EDIPARTY:
 139         if (!X509V3_add_value("EdiPartyName", "<unsupported>", &ret))
 140             return NULL;
 141         break;
 142
 143     case GEN_EMAIL:
 144         if (!X509V3_add_value_uchar("email", gen->d.ia5->data, &ret))
 145             return NULL;
 146         break;
 147
 148     case GEN_DNS:
 149         if (!X509V3_add_value_uchar("DNS", gen->d.ia5->data, &ret))
 150             return NULL;
 151         break;
 152
 153     case GEN_URI:
 154         if (!X509V3_add_value_uchar("URI", gen->d.ia5->data, &ret))
 155             return NULL;
 156         break;
 157
 158     case GEN_DIRNAME:
 159         if (X509_NAME_oneline(gen->d.dirn, oline, sizeof(oline)) == NULL
 160                 || !X509V3_add_value("DirName", oline, &ret))
 161             return NULL;
 162         break;
 163
 164     case GEN_IPADD:
 165         p = gen->d.ip->data;
 166         if (gen->d.ip->length == 4)
 167             BIO_snprintf(oline, sizeof(oline), "%d.%d.%d.%d",
 168                          p[0], p[1], p[2], p[3]);
 169         else if (gen->d.ip->length == 16) {
 170             oline[0] = 0;
 171             for (i = 0; i < 8; i++) {
 172                 BIO_snprintf(htmp, sizeof(htmp), "%X", p[0] << 8 | p[1]);
 173                 p += 2;
 174                 strcat(oline, htmp);
 175                 if (i != 7)
 176                     strcat(oline, ":");
 177             }
 178         } else {
 179             if (!X509V3_add_value("IP Address", "<invalid>", &ret))
 180                 return NULL;
 181             break;
 182         }
 183         if (!X509V3_add_value("IP Address", oline, &ret))
 184             return NULL;
 185         break;
 186
 187     case GEN_RID:
 188         i2t_ASN1_OBJECT(oline, 256, gen->d.rid);
 189         if (!X509V3_add_value("Registered ID", oline, &ret))
 190             return NULL;
 191         break;
 192     }
 193     return ret;
 194 }
 195
 196 int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen)
 197 {
 198     unsigned char *p;
 199     int i, nid;
 200
 201     switch (gen->type) {
 202     case GEN_OTHERNAME:
 203         nid = OBJ_obj2nid(gen->d.otherName->type_id);
 204         /* Validate the types are as we expect before we use them */
 205         if ((nid == NID_SRVName
 206              && gen->d.otherName->value->type != V_ASN1_IA5STRING)
 207                 || (nid != NID_SRVName
 208                     && gen->d.otherName->value->type != V_ASN1_UTF8STRING)) {
 209             BIO_printf(out, "othername:<unsupported>");
 210             break;
 211         }
 212
 213         switch (nid) {
 214         case NID_id_on_SmtpUTF8Mailbox:
 215             BIO_printf(out, "othername:SmtpUTF8Mailbox:%s",
 216                        gen->d.otherName->value->value.utf8string->data);
 217             break;
 218         case NID_XmppAddr:
 219             BIO_printf(out, "othername:XmppAddr:%s",
 220                        gen->d.otherName->value->value.utf8string->data);
 221             break;
 222         case NID_SRVName:
 223             BIO_printf(out, "othername:SRVName:%s",
 224                        gen->d.otherName->value->value.ia5string->data);
 225             break;
 226         case NID_ms_upn:
 227             BIO_printf(out, "othername:UPN:%s",
 228                        gen->d.otherName->value->value.utf8string->data);
 229             break;
 230         case NID_NAIRealm:
 231             BIO_printf(out, "othername:NAIRealm:%s",
 232                        gen->d.otherName->value->value.utf8string->data);
 233             break;
 234         default:
 235             BIO_printf(out, "othername:<unsupported>");
 236             break;
 237         }
 238         break;
 239
 240     case GEN_X400:
 241         BIO_printf(out, "X400Name:<unsupported>");
 242         break;
 243
 244     case GEN_EDIPARTY:
 245         /* Maybe fix this: it is supported now */
 246         BIO_printf(out, "EdiPartyName:<unsupported>");
 247         break;
 248
 249     case GEN_EMAIL:
 250         BIO_printf(out, "email:");
 251         ASN1_STRING_print(out, gen->d.ia5);
 252         break;
 253
 254     case GEN_DNS:
 255         BIO_printf(out, "DNS:");
 256         ASN1_STRING_print(out, gen->d.ia5);
 257         break;
 258
 259     case GEN_URI:
 260         BIO_printf(out, "URI:");
 261         ASN1_STRING_print(out, gen->d.ia5);
 262         break;
 263
 264     case GEN_DIRNAME:
 265         BIO_printf(out, "DirName:");
 266         X509_NAME_print_ex(out, gen->d.dirn, 0, XN_FLAG_ONELINE);
 267         break;
 268
 269     case GEN_IPADD:
 270         p = gen->d.ip->data;
 271         if (gen->d.ip->length == 4)
 272             BIO_printf(out, "IP Address:%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
 273         else if (gen->d.ip->length == 16) {
 274             BIO_printf(out, "IP Address");
 275             for (i = 0; i < 8; i++) {
 276                 BIO_printf(out, ":%X", p[0] << 8 | p[1]);
 277                 p += 2;
 278             }
 279         } else {
 280             BIO_printf(out, "IP Address:<invalid>");
 281             break;
 282         }
 283         break;
 284
 285     case GEN_RID:
 286         BIO_printf(out, "Registered ID:");
 287         i2a_ASN1_OBJECT(out, gen->d.rid);
 288         break;
 289     }
 290     return 1;
 291 }
 292
 293 static GENERAL_NAMES *v2i_issuer_alt(X509V3_EXT_METHOD *method,
 294                                      X509V3_CTX *ctx,
 295                                      STACK_OF(CONF_VALUE) *nval)
 296 {
 297     const int num = sk_CONF_VALUE_num(nval);
 298     GENERAL_NAMES *gens = sk_GENERAL_NAME_new_reserve(NULL, num);
 299     int i;
 300
 301     if (gens == NULL) {
 302         X509V3err(X509V3_F_V2I_ISSUER_ALT, ERR_R_MALLOC_FAILURE);
 303         sk_GENERAL_NAME_free(gens);
 304         return NULL;
 305     }
 306     for (i = 0; i < num; i++) {
 307         CONF_VALUE *cnf = sk_CONF_VALUE_value(nval, i);
 308
 309         if (!v3_name_cmp(cnf->name, "issuer")
 310             && cnf->value && strcmp(cnf->value, "copy") == 0) {
 311             if (!copy_issuer(ctx, gens))
 312                 goto err;
 313         } else {
 314             GENERAL_NAME *gen = v2i_GENERAL_NAME(method, ctx, cnf);
 315
 316             if (gen == NULL)
 317                 goto err;
 318             sk_GENERAL_NAME_push(gens, gen); /* no failure as it was reserved */
 319         }
 320     }
 321     return gens;
 322  err:
 323     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
 324     return NULL;
 325 }
 326
 327 /* Append subject altname of issuer to issuer alt name of subject */
 328
 329 static int copy_issuer(X509V3_CTX *ctx, GENERAL_NAMES *gens)
 330 {
 331     GENERAL_NAMES *ialt;
 332     GENERAL_NAME *gen;
 333     X509_EXTENSION *ext;
 334     int i, num;
 335
 336     if (ctx && (ctx->flags == CTX_TEST))
 337         return 1;
 338     if (!ctx || !ctx->issuer_cert) {
 339         X509V3err(X509V3_F_COPY_ISSUER, X509V3_R_NO_ISSUER_DETAILS);
 340         goto err;
 341     }
 342     i = X509_get_ext_by_NID(ctx->issuer_cert, NID_subject_alt_name, -1);
 343     if (i < 0)
 344         return 1;
 345     if ((ext = X509_get_ext(ctx->issuer_cert, i)) == NULL
 346         || (ialt = X509V3_EXT_d2i(ext)) == NULL) {
 347         X509V3err(X509V3_F_COPY_ISSUER, X509V3_R_ISSUER_DECODE_ERROR);
 348         goto err;
 349     }
 350
 351     num = sk_GENERAL_NAME_num(ialt);
 352     if (!sk_GENERAL_NAME_reserve(gens, num)) {
 353         X509V3err(X509V3_F_COPY_ISSUER, ERR_R_MALLOC_FAILURE);
 354         goto err;
 355     }
 356
 357     for (i = 0; i < num; i++) {
 358         gen = sk_GENERAL_NAME_value(ialt, i);
 359         sk_GENERAL_NAME_push(gens, gen);     /* no failure as it was reserved */
 360     }
 361     sk_GENERAL_NAME_free(ialt);
 362
 363     return 1;
 364
 365  err:
 366     return 0;
 367
 368 }
 369
 370 static GENERAL_NAMES *v2i_subject_alt(X509V3_EXT_METHOD *method,
 371                                       X509V3_CTX *ctx,
 372                                       STACK_OF(CONF_VALUE) *nval)
 373 {
 374     GENERAL_NAMES *gens;
 375     CONF_VALUE *cnf;
 376     const int num = sk_CONF_VALUE_num(nval);
 377     int i;
 378
 379     gens = sk_GENERAL_NAME_new_reserve(NULL, num);
 380     if (gens == NULL) {
 381         X509V3err(X509V3_F_V2I_SUBJECT_ALT, ERR_R_MALLOC_FAILURE);
 382         sk_GENERAL_NAME_free(gens);
 383         return NULL;
 384     }
 385
 386     for (i = 0; i < num; i++) {
 387         cnf = sk_CONF_VALUE_value(nval, i);
 388         if (!v3_name_cmp(cnf->name, "email")
 389             && cnf->value && strcmp(cnf->value, "copy") == 0) {
 390             if (!copy_email(ctx, gens, 0))
 391                 goto err;
 392         } else if (!v3_name_cmp(cnf->name, "email")
 393                    && cnf->value && strcmp(cnf->value, "move") == 0) {
 394             if (!copy_email(ctx, gens, 1))
 395                 goto err;
 396         } else {
 397             GENERAL_NAME *gen;
 398             if ((gen = v2i_GENERAL_NAME(method, ctx, cnf)) == NULL)
 399                 goto err;
 400             sk_GENERAL_NAME_push(gens, gen); /* no failure as it was reserved */
 401         }
 402     }
 403     return gens;
 404  err:
 405     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
 406     return NULL;
 407 }
 408
 409 /*
 410  * Copy any email addresses in a certificate or request to GENERAL_NAMES
 411  */
 412
 413 static int copy_email(X509V3_CTX *ctx, GENERAL_NAMES *gens, int move_p)
 414 {
 415     X509_NAME *nm;
 416     ASN1_IA5STRING *email = NULL;
 417     X509_NAME_ENTRY *ne;
 418     GENERAL_NAME *gen = NULL;
 419     int i = -1;
 420
 421     if (ctx != NULL && ctx->flags == CTX_TEST)
 422         return 1;
 423     if (ctx == NULL
 424         || (ctx->subject_cert == NULL && ctx->subject_req == NULL)) {
 425         X509V3err(X509V3_F_COPY_EMAIL, X509V3_R_NO_SUBJECT_DETAILS);
 426         goto err;
 427     }
 428     /* Find the subject name */
 429     if (ctx->subject_cert)
 430         nm = X509_get_subject_name(ctx->subject_cert);
 431     else
 432         nm = X509_REQ_get_subject_name(ctx->subject_req);
 433
 434     /* Now add any email address(es) to STACK */
 435     while ((i = X509_NAME_get_index_by_NID(nm,
 436                                            NID_pkcs9_emailAddress, i)) >= 0) {
 437         ne = X509_NAME_get_entry(nm, i);
 438         email = ASN1_STRING_dup(X509_NAME_ENTRY_get_data(ne));
 439         if (move_p) {
 440             X509_NAME_delete_entry(nm, i);
 441             X509_NAME_ENTRY_free(ne);
 442             i--;
 443         }
 444         if (email == NULL || (gen = GENERAL_NAME_new()) == NULL) {
 445             X509V3err(X509V3_F_COPY_EMAIL, ERR_R_MALLOC_FAILURE);
 446             goto err;
 447         }
 448         gen->d.ia5 = email;
 449         email = NULL;
 450         gen->type = GEN_EMAIL;
 451         if (!sk_GENERAL_NAME_push(gens, gen)) {
 452             X509V3err(X509V3_F_COPY_EMAIL, ERR_R_MALLOC_FAILURE);
 453             goto err;
 454         }
 455         gen = NULL;
 456     }
 457
 458     return 1;
 459
 460  err:
 461     GENERAL_NAME_free(gen);
 462     ASN1_IA5STRING_free(email);
 463     return 0;
 464
 465 }
 466
 467 GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method,
 468                                  X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval)
 469 {
 470     GENERAL_NAME *gen;
 471     GENERAL_NAMES *gens;
 472     CONF_VALUE *cnf;
 473     const int num = sk_CONF_VALUE_num(nval);
 474     int i;
 475
 476     gens = sk_GENERAL_NAME_new_reserve(NULL, num);
 477     if (gens == NULL) {
 478         X509V3err(X509V3_F_V2I_GENERAL_NAMES, ERR_R_MALLOC_FAILURE);
 479         sk_GENERAL_NAME_free(gens);
 480         return NULL;
 481     }
 482
 483     for (i = 0; i < num; i++) {
 484         cnf = sk_CONF_VALUE_value(nval, i);
 485         if ((gen = v2i_GENERAL_NAME(method, ctx, cnf)) == NULL)
 486             goto err;
 487         sk_GENERAL_NAME_push(gens, gen);    /* no failure as it was reserved */
 488     }
 489     return gens;
 490  err:
 491     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
 492     return NULL;
 493 }
 494
 495 GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method,
 496                                X509V3_CTX *ctx, CONF_VALUE *cnf)
 497 {
 498     return v2i_GENERAL_NAME_ex(NULL, method, ctx, cnf, 0);
 499 }
 500
 501 GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out,
 502                                const X509V3_EXT_METHOD *method,
 503                                X509V3_CTX *ctx, int gen_type, const char *value,
 504                                int is_nc)
 505 {
 506     char is_string = 0;
 507     GENERAL_NAME *gen = NULL;
 508
 509     if (!value) {
 510         X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_MISSING_VALUE);
 511         return NULL;
 512     }
 513
 514     if (out)
 515         gen = out;
 516     else {
 517         gen = GENERAL_NAME_new();
 518         if (gen == NULL) {
 519             X509V3err(X509V3_F_A2I_GENERAL_NAME, ERR_R_MALLOC_FAILURE);
 520             return NULL;
 521         }
 522     }
 523
 524     switch (gen_type) {
 525     case GEN_URI:
 526     case GEN_EMAIL:
 527     case GEN_DNS:
 528         is_string = 1;
 529         break;
 530
 531     case GEN_RID:
 532         {
 533             ASN1_OBJECT *obj;
 534             if ((obj = OBJ_txt2obj(value, 0)) == NULL) {
 535                 X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_BAD_OBJECT);
 536                 ERR_add_error_data(2, "value=", value);
 537                 goto err;
 538             }
 539             gen->d.rid = obj;
 540         }
 541         break;
 542
 543     case GEN_IPADD:
 544         if (is_nc)
 545             gen->d.ip = a2i_IPADDRESS_NC(value);
 546         else
 547             gen->d.ip = a2i_IPADDRESS(value);
 548         if (gen->d.ip == NULL) {
 549             X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_BAD_IP_ADDRESS);
 550             ERR_add_error_data(2, "value=", value);
 551             goto err;
 552         }
 553         break;
 554
 555     case GEN_DIRNAME:
 556         if (!do_dirname(gen, value, ctx)) {
 557             X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_DIRNAME_ERROR);
 558             goto err;
 559         }
 560         break;
 561
 562     case GEN_OTHERNAME:
 563         if (!do_othername(gen, value, ctx)) {
 564             X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_OTHERNAME_ERROR);
 565             goto err;
 566         }
 567         break;
 568     default:
 569         X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_UNSUPPORTED_TYPE);
 570         goto err;
 571     }
 572
 573     if (is_string) {
 574         if ((gen->d.ia5 = ASN1_IA5STRING_new()) == NULL ||
 575             !ASN1_STRING_set(gen->d.ia5, (unsigned char *)value,
 576                              strlen(value))) {
 577             X509V3err(X509V3_F_A2I_GENERAL_NAME, ERR_R_MALLOC_FAILURE);
 578             goto err;
 579         }
 580     }
 581
 582     gen->type = gen_type;
 583
 584     return gen;
 585
 586  err:
 587     if (!out)
 588         GENERAL_NAME_free(gen);
 589     return NULL;
 590 }
 591
 592 GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out,
 593                                   const X509V3_EXT_METHOD *method,
 594                                   X509V3_CTX *ctx, CONF_VALUE *cnf, int is_nc)
 595 {
 596     int type;
 597
 598     char *name, *value;
 599
 600     name = cnf->name;
 601     value = cnf->value;
 602
 603     if (!value) {
 604         X509V3err(X509V3_F_V2I_GENERAL_NAME_EX, X509V3_R_MISSING_VALUE);
 605         return NULL;
 606     }
 607
 608     if (!v3_name_cmp(name, "email"))
 609         type = GEN_EMAIL;
 610     else if (!v3_name_cmp(name, "URI"))
 611         type = GEN_URI;
 612     else if (!v3_name_cmp(name, "DNS"))
 613         type = GEN_DNS;
 614     else if (!v3_name_cmp(name, "RID"))
 615         type = GEN_RID;
 616     else if (!v3_name_cmp(name, "IP"))
 617         type = GEN_IPADD;
 618     else if (!v3_name_cmp(name, "dirName"))
 619         type = GEN_DIRNAME;
 620     else if (!v3_name_cmp(name, "otherName"))
 621         type = GEN_OTHERNAME;
 622     else {
 623         X509V3err(X509V3_F_V2I_GENERAL_NAME_EX, X509V3_R_UNSUPPORTED_OPTION);
 624         ERR_add_error_data(2, "name=", name);
 625         return NULL;
 626     }
 627
 628     return a2i_GENERAL_NAME(out, method, ctx, type, value, is_nc);
 629
 630 }
 631
 632 static int do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
 633 {
 634     char *objtmp = NULL, *p;
 635     int objlen;
 636
 637     if ((p = strchr(value, ';')) == NULL)
 638         return 0;
 639     if ((gen->d.otherName = OTHERNAME_new()) == NULL)
 640         return 0;
 641     /*
 642      * Free this up because we will overwrite it. no need to free type_id
 643      * because it is static
 644      */
 645     ASN1_TYPE_free(gen->d.otherName->value);
 646     if ((gen->d.otherName->value = ASN1_generate_v3(p + 1, ctx)) == NULL)
 647         return 0;
 648     objlen = p - value;
 649     objtmp = OPENSSL_strndup(value, objlen);
 650     if (objtmp == NULL)
 651         return 0;
 652     gen->d.otherName->type_id = OBJ_txt2obj(objtmp, 0);
 653     OPENSSL_free(objtmp);
 654     if (!gen->d.otherName->type_id)
 655         return 0;
 656     return 1;
 657 }
 658
 659 static int do_dirname(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
 660 {
 661     int ret = 0;
 662     STACK_OF(CONF_VALUE) *sk = NULL;
 663     X509_NAME *nm;
 664
 665     if ((nm = X509_NAME_new()) == NULL)
 666         goto err;
 667     sk = X509V3_get_section(ctx, value);
 668     if (!sk) {
 669         X509V3err(X509V3_F_DO_DIRNAME, X509V3_R_SECTION_NOT_FOUND);
 670         ERR_add_error_data(2, "section=", value);
 671         goto err;
 672     }
 673     /* FIXME: should allow other character types... */
 674     ret = X509V3_NAME_from_section(nm, sk, MBSTRING_ASC);
 675     if (!ret)
 676         goto err;
 677     gen->d.dirn = nm;
 678
 679 err:
 680     if (ret == 0)
 681         X509_NAME_free(nm);
 682     X509V3_section_free(ctx, sk);
 683     return ret;
 684 }