crypto/x509v3/v3_utl.c

   1 /* v3_utl.c */
   2 /*
   3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   4  * project.
   5  */
   6 /* ====================================================================
   7  * Copyright (c) 1999-2003 The OpenSSL Project.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  * 3. All advertising materials mentioning features or use of this
  22  *    software must display the following acknowledgment:
  23  *    "This product includes software developed by the OpenSSL Project
  24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  25  *
  26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  27  *    endorse or promote products derived from this software without
  28  *    prior written permission. For written permission, please contact
  29  *    licensing@OpenSSL.org.
  30  *
  31  * 5. Products derived from this software may not be called "OpenSSL"
  32  *    nor may "OpenSSL" appear in their names without prior written
  33  *    permission of the OpenSSL Project.
  34  *
  35  * 6. Redistributions of any form whatsoever must retain the following
  36  *    acknowledgment:
  37  *    "This product includes software developed by the OpenSSL Project
  38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  51  * OF THE POSSIBILITY OF SUCH DAMAGE.
  52  * ====================================================================
  53  *
  54  * This product includes cryptographic software written by Eric Young
  55  * (eay@cryptsoft.com).  This product includes software written by Tim
  56  * Hudson (tjh@cryptsoft.com).
  57  *
  58  */
  59 /* X509 v3 extension utilities */
  60
  61 #include <stdio.h>
  62 #include <ctype.h>
  63 #include "internal/cryptlib.h"
  64 #include <openssl/conf.h>
  65 #include <openssl/x509v3.h>
  66 #include "internal/x509_int.h"
  67 #include <openssl/bn.h>
  68
  69 static char *strip_spaces(char *name);
  70 static int sk_strcmp(const char *const *a, const char *const *b);
  71 static STACK_OF(OPENSSL_STRING) *get_email(X509_NAME *name,
  72                                            GENERAL_NAMES *gens);
  73 static void str_free(OPENSSL_STRING str);
  74 static int append_ia5(STACK_OF(OPENSSL_STRING) **sk, ASN1_IA5STRING *email);
  75
  76 static int ipv4_from_asc(unsigned char *v4, const char *in);
  77 static int ipv6_from_asc(unsigned char *v6, const char *in);
  78 static int ipv6_cb(const char *elem, int len, void *usr);
  79 static int ipv6_hex(unsigned char *out, const char *in, int inlen);
  80
  81 /* Add a CONF_VALUE name value pair to stack */
  82
  83 int X509V3_add_value(const char *name, const char *value,
  84                      STACK_OF(CONF_VALUE) **extlist)
  85 {
  86     CONF_VALUE *vtmp = NULL;
  87     char *tname = NULL, *tvalue = NULL;
  88
  89     if (name && (tname = OPENSSL_strdup(name)) == NULL)
  90         goto err;
  91     if (value && (tvalue = OPENSSL_strdup(value)) == NULL)
  92         goto err;
  93     if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == NULL)
  94         goto err;
  95     if (*extlist == NULL && (*extlist = sk_CONF_VALUE_new_null()) == NULL)
  96         goto err;
  97     vtmp->section = NULL;
  98     vtmp->name = tname;
  99     vtmp->value = tvalue;
 100     if (!sk_CONF_VALUE_push(*extlist, vtmp))
 101         goto err;
 102     return 1;
 103  err:
 104     X509V3err(X509V3_F_X509V3_ADD_VALUE, ERR_R_MALLOC_FAILURE);
 105     OPENSSL_free(vtmp);
 106     OPENSSL_free(tname);
 107     OPENSSL_free(tvalue);
 108     return 0;
 109 }
 110
 111 int X509V3_add_value_uchar(const char *name, const unsigned char *value,
 112                            STACK_OF(CONF_VALUE) **extlist)
 113 {
 114     return X509V3_add_value(name, (const char *)value, extlist);
 115 }
 116
 117 /* Free function for STACK_OF(CONF_VALUE) */
 118
 119 void X509V3_conf_free(CONF_VALUE *conf)
 120 {
 121     if (!conf)
 122         return;
 123     OPENSSL_free(conf->name);
 124     OPENSSL_free(conf->value);
 125     OPENSSL_free(conf->section);
 126     OPENSSL_free(conf);
 127 }
 128
 129 int X509V3_add_value_bool(const char *name, int asn1_bool,
 130                           STACK_OF(CONF_VALUE) **extlist)
 131 {
 132     if (asn1_bool)
 133         return X509V3_add_value(name, "TRUE", extlist);
 134     return X509V3_add_value(name, "FALSE", extlist);
 135 }
 136
 137 int X509V3_add_value_bool_nf(char *name, int asn1_bool,
 138                              STACK_OF(CONF_VALUE) **extlist)
 139 {
 140     if (asn1_bool)
 141         return X509V3_add_value(name, "TRUE", extlist);
 142     return 1;
 143 }
 144
 145 char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *method, ASN1_ENUMERATED *a)
 146 {
 147     BIGNUM *bntmp = NULL;
 148     char *strtmp = NULL;
 149
 150     if (!a)
 151         return NULL;
 152     if ((bntmp = ASN1_ENUMERATED_to_BN(a, NULL)) == NULL
 153         || (strtmp = BN_bn2dec(bntmp)) == NULL)
 154         X509V3err(X509V3_F_I2S_ASN1_ENUMERATED, ERR_R_MALLOC_FAILURE);
 155     BN_free(bntmp);
 156     return strtmp;
 157 }
 158
 159 char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, ASN1_INTEGER *a)
 160 {
 161     BIGNUM *bntmp = NULL;
 162     char *strtmp = NULL;
 163
 164     if (!a)
 165         return NULL;
 166     if ((bntmp = ASN1_INTEGER_to_BN(a, NULL)) == NULL
 167         || (strtmp = BN_bn2dec(bntmp)) == NULL)
 168         X509V3err(X509V3_F_I2S_ASN1_INTEGER, ERR_R_MALLOC_FAILURE);
 169     BN_free(bntmp);
 170     return strtmp;
 171 }
 172
 173 ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, char *value)
 174 {
 175     BIGNUM *bn = NULL;
 176     ASN1_INTEGER *aint;
 177     int isneg, ishex;
 178     int ret;
 179     if (value == NULL) {
 180         X509V3err(X509V3_F_S2I_ASN1_INTEGER, X509V3_R_INVALID_NULL_VALUE);
 181         return NULL;
 182     }
 183     bn = BN_new();
 184     if (bn == NULL) {
 185         X509V3err(X509V3_F_S2I_ASN1_INTEGER, ERR_R_MALLOC_FAILURE);
 186         return NULL;
 187     }
 188     if (value[0] == '-') {
 189         value++;
 190         isneg = 1;
 191     } else
 192         isneg = 0;
 193
 194     if (value[0] == '0' && ((value[1] == 'x') || (value[1] == 'X'))) {
 195         value += 2;
 196         ishex = 1;
 197     } else
 198         ishex = 0;
 199
 200     if (ishex)
 201         ret = BN_hex2bn(&bn, value);
 202     else
 203         ret = BN_dec2bn(&bn, value);
 204
 205     if (!ret || value[ret]) {
 206         BN_free(bn);
 207         X509V3err(X509V3_F_S2I_ASN1_INTEGER, X509V3_R_BN_DEC2BN_ERROR);
 208         return NULL;
 209     }
 210
 211     if (isneg && BN_is_zero(bn))
 212         isneg = 0;
 213
 214     aint = BN_to_ASN1_INTEGER(bn, NULL);
 215     BN_free(bn);
 216     if (!aint) {
 217         X509V3err(X509V3_F_S2I_ASN1_INTEGER,
 218                   X509V3_R_BN_TO_ASN1_INTEGER_ERROR);
 219         return NULL;
 220     }
 221     if (isneg)
 222         aint->type |= V_ASN1_NEG;
 223     return aint;
 224 }
 225
 226 int X509V3_add_value_int(const char *name, ASN1_INTEGER *aint,
 227                          STACK_OF(CONF_VALUE) **extlist)
 228 {
 229     char *strtmp;
 230     int ret;
 231
 232     if (!aint)
 233         return 1;
 234     if ((strtmp = i2s_ASN1_INTEGER(NULL, aint)) == NULL)
 235         return 0;
 236     ret = X509V3_add_value(name, strtmp, extlist);
 237     OPENSSL_free(strtmp);
 238     return ret;
 239 }
 240
 241 int X509V3_get_value_bool(CONF_VALUE *value, int *asn1_bool)
 242 {
 243     char *btmp;
 244
 245     if ((btmp = value->value) == NULL)
 246         goto err;
 247     if (strcmp(btmp, "TRUE") == 0
 248         || strcmp(btmp, "true") == 0
 249         || strcmp(btmp, "Y") == 0
 250         || strcmp(btmp, "y") == 0
 251         || strcmp(btmp, "YES") == 0
 252         || strcmp(btmp, "yes") == 0) {
 253         *asn1_bool = 0xff;
 254         return 1;
 255     }
 256     if (strcmp(btmp, "FALSE") == 0
 257         || strcmp(btmp, "false") == 0
 258         || strcmp(btmp, "N") == 0
 259         || strcmp(btmp, "n") == 0
 260         || strcmp(btmp, "NO") == 0
 261         || strcmp(btmp, "no") == 0) {
 262         *asn1_bool = 0;
 263         return 1;
 264     }
 265  err:
 266     X509V3err(X509V3_F_X509V3_GET_VALUE_BOOL,
 267               X509V3_R_INVALID_BOOLEAN_STRING);
 268     X509V3_conf_err(value);
 269     return 0;
 270 }
 271
 272 int X509V3_get_value_int(CONF_VALUE *value, ASN1_INTEGER **aint)
 273 {
 274     ASN1_INTEGER *itmp;
 275
 276     if ((itmp = s2i_ASN1_INTEGER(NULL, value->value)) == NULL) {
 277         X509V3_conf_err(value);
 278         return 0;
 279     }
 280     *aint = itmp;
 281     return 1;
 282 }
 283
 284 #define HDR_NAME        1
 285 #define HDR_VALUE       2
 286
 287 /*
 288  * #define DEBUG
 289  */
 290
 291 STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line)
 292 {
 293     char *p, *q, c;
 294     char *ntmp, *vtmp;
 295     STACK_OF(CONF_VALUE) *values = NULL;
 296     char *linebuf;
 297     int state;
 298     /* We are going to modify the line so copy it first */
 299     linebuf = OPENSSL_strdup(line);
 300     if (linebuf == NULL) {
 301         X509V3err(X509V3_F_X509V3_PARSE_LIST, ERR_R_MALLOC_FAILURE);
 302         goto err;
 303     }
 304     state = HDR_NAME;
 305     ntmp = NULL;
 306     /* Go through all characters */
 307     for (p = linebuf, q = linebuf; (c = *p) && (c != '\r') && (c != '\n');
 308          p++) {
 309
 310         switch (state) {
 311         case HDR_NAME:
 312             if (c == ':') {
 313                 state = HDR_VALUE;
 314                 *p = 0;
 315                 ntmp = strip_spaces(q);
 316                 if (!ntmp) {
 317                     X509V3err(X509V3_F_X509V3_PARSE_LIST,
 318                               X509V3_R_INVALID_NULL_NAME);
 319                     goto err;
 320                 }
 321                 q = p + 1;
 322             } else if (c == ',') {
 323                 *p = 0;
 324                 ntmp = strip_spaces(q);
 325                 q = p + 1;
 326                 if (!ntmp) {
 327                     X509V3err(X509V3_F_X509V3_PARSE_LIST,
 328                               X509V3_R_INVALID_NULL_NAME);
 329                     goto err;
 330                 }
 331                 X509V3_add_value(ntmp, NULL, &values);
 332             }
 333             break;
 334
 335         case HDR_VALUE:
 336             if (c == ',') {
 337                 state = HDR_NAME;
 338                 *p = 0;
 339                 vtmp = strip_spaces(q);
 340                 if (!vtmp) {
 341                     X509V3err(X509V3_F_X509V3_PARSE_LIST,
 342                               X509V3_R_INVALID_NULL_VALUE);
 343                     goto err;
 344                 }
 345                 X509V3_add_value(ntmp, vtmp, &values);
 346                 ntmp = NULL;
 347                 q = p + 1;
 348             }
 349
 350         }
 351     }
 352
 353     if (state == HDR_VALUE) {
 354         vtmp = strip_spaces(q);
 355         if (!vtmp) {
 356             X509V3err(X509V3_F_X509V3_PARSE_LIST,
 357                       X509V3_R_INVALID_NULL_VALUE);
 358             goto err;
 359         }
 360         X509V3_add_value(ntmp, vtmp, &values);
 361     } else {
 362         ntmp = strip_spaces(q);
 363         if (!ntmp) {
 364             X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_NAME);
 365             goto err;
 366         }
 367         X509V3_add_value(ntmp, NULL, &values);
 368     }
 369     OPENSSL_free(linebuf);
 370     return values;
 371
 372  err:
 373     OPENSSL_free(linebuf);
 374     sk_CONF_VALUE_pop_free(values, X509V3_conf_free);
 375     return NULL;
 376
 377 }
 378
 379 /* Delete leading and trailing spaces from a string */
 380 static char *strip_spaces(char *name)
 381 {
 382     char *p, *q;
 383     /* Skip over leading spaces */
 384     p = name;
 385     while (*p && isspace((unsigned char)*p))
 386         p++;
 387     if (!*p)
 388         return NULL;
 389     q = p + strlen(p) - 1;
 390     while ((q != p) && isspace((unsigned char)*q))
 391         q--;
 392     if (p != q)
 393         q[1] = 0;
 394     if (!*p)
 395         return NULL;
 396     return p;
 397 }
 398
 399 /* hex string utilities */
 400
 401 /*
 402  * Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its
 403  * hex representation @@@ (Contents of buffer are always kept in ASCII, also
 404  * on EBCDIC machines)
 405  */
 406
 407 char *hex_to_string(const unsigned char *buffer, long len)
 408 {
 409     char *tmp, *q;
 410     const unsigned char *p;
 411     int i;
 412     const static char hexdig[] = "0123456789ABCDEF";
 413     if (!buffer || !len)
 414         return NULL;
 415     if ((tmp = OPENSSL_malloc(len * 3 + 1)) == NULL) {
 416         X509V3err(X509V3_F_HEX_TO_STRING, ERR_R_MALLOC_FAILURE);
 417         return NULL;
 418     }
 419     q = tmp;
 420     for (i = 0, p = buffer; i < len; i++, p++) {
 421         *q++ = hexdig[(*p >> 4) & 0xf];
 422         *q++ = hexdig[*p & 0xf];
 423         *q++ = ':';
 424     }
 425     q[-1] = 0;
 426 #ifdef CHARSET_EBCDIC
 427     ebcdic2ascii(tmp, tmp, q - tmp - 1);
 428 #endif
 429
 430     return tmp;
 431 }
 432
 433 /*
 434  * Give a string of hex digits convert to a buffer
 435  */
 436
 437 unsigned char *string_to_hex(const char *str, long *len)
 438 {
 439     unsigned char *hexbuf, *q;
 440     unsigned char ch, cl, *p;
 441     if (!str) {
 442         X509V3err(X509V3_F_STRING_TO_HEX, X509V3_R_INVALID_NULL_ARGUMENT);
 443         return NULL;
 444     }
 445     if ((hexbuf = OPENSSL_malloc(strlen(str) >> 1)) == NULL)
 446         goto err;
 447     for (p = (unsigned char *)str, q = hexbuf; *p;) {
 448         ch = *p++;
 449 #ifdef CHARSET_EBCDIC
 450         ch = os_toebcdic[ch];
 451 #endif
 452         if (ch == ':')
 453             continue;
 454         cl = *p++;
 455 #ifdef CHARSET_EBCDIC
 456         cl = os_toebcdic[cl];
 457 #endif
 458         if (!cl) {
 459             X509V3err(X509V3_F_STRING_TO_HEX, X509V3_R_ODD_NUMBER_OF_DIGITS);
 460             OPENSSL_free(hexbuf);
 461             return NULL;
 462         }
 463         if (isupper(ch))
 464             ch = tolower(ch);
 465         if (isupper(cl))
 466             cl = tolower(cl);
 467
 468         if ((ch >= '0') && (ch <= '9'))
 469             ch -= '0';
 470         else if ((ch >= 'a') && (ch <= 'f'))
 471             ch -= 'a' - 10;
 472         else
 473             goto badhex;
 474
 475         if ((cl >= '0') && (cl <= '9'))
 476             cl -= '0';
 477         else if ((cl >= 'a') && (cl <= 'f'))
 478             cl -= 'a' - 10;
 479         else
 480             goto badhex;
 481
 482         *q++ = (ch << 4) | cl;
 483     }
 484
 485     if (len)
 486         *len = q - hexbuf;
 487
 488     return hexbuf;
 489
 490  err:
 491     OPENSSL_free(hexbuf);
 492     X509V3err(X509V3_F_STRING_TO_HEX, ERR_R_MALLOC_FAILURE);
 493     return NULL;
 494
 495  badhex:
 496     OPENSSL_free(hexbuf);
 497     X509V3err(X509V3_F_STRING_TO_HEX, X509V3_R_ILLEGAL_HEX_DIGIT);
 498     return NULL;
 499
 500 }
 501
 502 /*
 503  * V2I name comparison function: returns zero if 'name' matches cmp or cmp.*
 504  */
 505
 506 int name_cmp(const char *name, const char *cmp)
 507 {
 508     int len, ret;
 509     char c;
 510     len = strlen(cmp);
 511     if ((ret = strncmp(name, cmp, len)))
 512         return ret;
 513     c = name[len];
 514     if (!c || (c == '.'))
 515         return 0;
 516     return 1;
 517 }
 518
 519 static int sk_strcmp(const char *const *a, const char *const *b)
 520 {
 521     return strcmp(*a, *b);
 522 }
 523
 524 STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x)
 525 {
 526     GENERAL_NAMES *gens;
 527     STACK_OF(OPENSSL_STRING) *ret;
 528
 529     gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
 530     ret = get_email(X509_get_subject_name(x), gens);
 531     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
 532     return ret;
 533 }
 534
 535 STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x)
 536 {
 537     AUTHORITY_INFO_ACCESS *info;
 538     STACK_OF(OPENSSL_STRING) *ret = NULL;
 539     int i;
 540
 541     info = X509_get_ext_d2i(x, NID_info_access, NULL, NULL);
 542     if (!info)
 543         return NULL;
 544     for (i = 0; i < sk_ACCESS_DESCRIPTION_num(info); i++) {
 545         ACCESS_DESCRIPTION *ad = sk_ACCESS_DESCRIPTION_value(info, i);
 546         if (OBJ_obj2nid(ad->method) == NID_ad_OCSP) {
 547             if (ad->location->type == GEN_URI) {
 548                 if (!append_ia5
 549                     (&ret, ad->location->d.uniformResourceIdentifier))
 550                     break;
 551             }
 552         }
 553     }
 554     AUTHORITY_INFO_ACCESS_free(info);
 555     return ret;
 556 }
 557
 558 STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x)
 559 {
 560     GENERAL_NAMES *gens;
 561     STACK_OF(X509_EXTENSION) *exts;
 562     STACK_OF(OPENSSL_STRING) *ret;
 563
 564     exts = X509_REQ_get_extensions(x);
 565     gens = X509V3_get_d2i(exts, NID_subject_alt_name, NULL, NULL);
 566     ret = get_email(X509_REQ_get_subject_name(x), gens);
 567     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
 568     sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
 569     return ret;
 570 }
 571
 572 static STACK_OF(OPENSSL_STRING) *get_email(X509_NAME *name,
 573                                            GENERAL_NAMES *gens)
 574 {
 575     STACK_OF(OPENSSL_STRING) *ret = NULL;
 576     X509_NAME_ENTRY *ne;
 577     ASN1_IA5STRING *email;
 578     GENERAL_NAME *gen;
 579     int i;
 580     /* Now add any email address(es) to STACK */
 581     i = -1;
 582     /* First supplied X509_NAME */
 583     while ((i = X509_NAME_get_index_by_NID(name,
 584                                            NID_pkcs9_emailAddress, i)) >= 0) {
 585         ne = X509_NAME_get_entry(name, i);
 586         email = X509_NAME_ENTRY_get_data(ne);
 587         if (!append_ia5(&ret, email))
 588             return NULL;
 589     }
 590     for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
 591         gen = sk_GENERAL_NAME_value(gens, i);
 592         if (gen->type != GEN_EMAIL)
 593             continue;
 594         if (!append_ia5(&ret, gen->d.ia5))
 595             return NULL;
 596     }
 597     return ret;
 598 }
 599
 600 static void str_free(OPENSSL_STRING str)
 601 {
 602     OPENSSL_free(str);
 603 }
 604
 605 static int append_ia5(STACK_OF(OPENSSL_STRING) **sk, ASN1_IA5STRING *email)
 606 {
 607     char *emtmp;
 608     /* First some sanity checks */
 609     if (email->type != V_ASN1_IA5STRING)
 610         return 1;
 611     if (!email->data || !email->length)
 612         return 1;
 613     if (*sk == NULL)
 614         *sk = sk_OPENSSL_STRING_new(sk_strcmp);
 615     if (*sk == NULL)
 616         return 0;
 617     /* Don't add duplicates */
 618     if (sk_OPENSSL_STRING_find(*sk, (char *)email->data) != -1)
 619         return 1;
 620     emtmp = OPENSSL_strdup((char *)email->data);
 621     if (emtmp == NULL || !sk_OPENSSL_STRING_push(*sk, emtmp)) {
 622         X509_email_free(*sk);
 623         *sk = NULL;
 624         return 0;
 625     }
 626     return 1;
 627 }
 628
 629 void X509_email_free(STACK_OF(OPENSSL_STRING) *sk)
 630 {
 631     sk_OPENSSL_STRING_pop_free(sk, str_free);
 632 }
 633
 634 typedef int (*equal_fn) (const unsigned char *pattern, size_t pattern_len,
 635                          const unsigned char *subject, size_t subject_len,
 636                          unsigned int flags);
 637
 638 /* Skip pattern prefix to match "wildcard" subject */
 639 static void skip_prefix(const unsigned char **p, size_t *plen,
 640                         const unsigned char *subject, size_t subject_len,
 641                         unsigned int flags)
 642 {
 643     const unsigned char *pattern = *p;
 644     size_t pattern_len = *plen;
 645
 646     /*
 647      * If subject starts with a leading '.' followed by more octets, and
 648      * pattern is longer, compare just an equal-length suffix with the
 649      * full subject (starting at the '.'), provided the prefix contains
 650      * no NULs.
 651      */
 652     if ((flags & _X509_CHECK_FLAG_DOT_SUBDOMAINS) == 0)
 653         return;
 654
 655     while (pattern_len > subject_len && *pattern) {
 656         if ((flags & X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS) &&
 657             *pattern == '.')
 658             break;
 659         ++pattern;
 660         --pattern_len;
 661     }
 662
 663     /* Skip if entire prefix acceptable */
 664     if (pattern_len == subject_len) {
 665         *p = pattern;
 666         *plen = pattern_len;
 667     }
 668 }
 669
 670 /* Compare while ASCII ignoring case. */
 671 static int equal_nocase(const unsigned char *pattern, size_t pattern_len,
 672                         const unsigned char *subject, size_t subject_len,
 673                         unsigned int flags)
 674 {
 675     skip_prefix(&pattern, &pattern_len, subject, subject_len, flags);
 676     if (pattern_len != subject_len)
 677         return 0;
 678     while (pattern_len) {
 679         unsigned char l = *pattern;
 680         unsigned char r = *subject;
 681         /* The pattern must not contain NUL characters. */
 682         if (l == 0)
 683             return 0;
 684         if (l != r) {
 685             if ('A' <= l && l <= 'Z')
 686                 l = (l - 'A') + 'a';
 687             if ('A' <= r && r <= 'Z')
 688                 r = (r - 'A') + 'a';
 689             if (l != r)
 690                 return 0;
 691         }
 692         ++pattern;
 693         ++subject;
 694         --pattern_len;
 695     }
 696     return 1;
 697 }
 698
 699 /* Compare using memcmp. */
 700 static int equal_case(const unsigned char *pattern, size_t pattern_len,
 701                       const unsigned char *subject, size_t subject_len,
 702                       unsigned int flags)
 703 {
 704     skip_prefix(&pattern, &pattern_len, subject, subject_len, flags);
 705     if (pattern_len != subject_len)
 706         return 0;
 707     return !memcmp(pattern, subject, pattern_len);
 708 }
 709
 710 /*
 711  * RFC 5280, section 7.5, requires that only the domain is compared in a
 712  * case-insensitive manner.
 713  */
 714 static int equal_email(const unsigned char *a, size_t a_len,
 715                        const unsigned char *b, size_t b_len,
 716                        unsigned int unused_flags)
 717 {
 718     size_t i = a_len;
 719     if (a_len != b_len)
 720         return 0;
 721     /*
 722      * We search backwards for the '@' character, so that we do not have to
 723      * deal with quoted local-parts.  The domain part is compared in a
 724      * case-insensitive manner.
 725      */
 726     while (i > 0) {
 727         --i;
 728         if (a[i] == '@' || b[i] == '@') {
 729             if (!equal_nocase(a + i, a_len - i, b + i, a_len - i, 0))
 730                 return 0;
 731             break;
 732         }
 733     }
 734     if (i == 0)
 735         i = a_len;
 736     return equal_case(a, i, b, i, 0);
 737 }
 738
 739 /*
 740  * Compare the prefix and suffix with the subject, and check that the
 741  * characters in-between are valid.
 742  */
 743 static int wildcard_match(const unsigned char *prefix, size_t prefix_len,
 744                           const unsigned char *suffix, size_t suffix_len,
 745                           const unsigned char *subject, size_t subject_len,
 746                           unsigned int flags)
 747 {
 748     const unsigned char *wildcard_start;
 749     const unsigned char *wildcard_end;
 750     const unsigned char *p;
 751     int allow_multi = 0;
 752     int allow_idna = 0;
 753
 754     if (subject_len < prefix_len + suffix_len)
 755         return 0;
 756     if (!equal_nocase(prefix, prefix_len, subject, prefix_len, flags))
 757         return 0;
 758     wildcard_start = subject + prefix_len;
 759     wildcard_end = subject + (subject_len - suffix_len);
 760     if (!equal_nocase(wildcard_end, suffix_len, suffix, suffix_len, flags))
 761         return 0;
 762     /*
 763      * If the wildcard makes up the entire first label, it must match at
 764      * least one character.
 765      */
 766     if (prefix_len == 0 && *suffix == '.') {
 767         if (wildcard_start == wildcard_end)
 768             return 0;
 769         allow_idna = 1;
 770         if (flags & X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS)
 771             allow_multi = 1;
 772     }
 773     /* IDNA labels cannot match partial wildcards */
 774     if (!allow_idna &&
 775         subject_len >= 4 && strncasecmp((char *)subject, "xn--", 4) == 0)
 776         return 0;
 777     /* The wildcard may match a literal '*' */
 778     if (wildcard_end == wildcard_start + 1 && *wildcard_start == '*')
 779         return 1;
 780     /*
 781      * Check that the part matched by the wildcard contains only
 782      * permitted characters and only matches a single label unless
 783      * allow_multi is set.
 784      */
 785     for (p = wildcard_start; p != wildcard_end; ++p)
 786         if (!(('0' <= *p && *p <= '9') ||
 787               ('A' <= *p && *p <= 'Z') ||
 788               ('a' <= *p && *p <= 'z') ||
 789               *p == '-' || (allow_multi && *p == '.')))
 790             return 0;
 791     return 1;
 792 }
 793
 794 #define LABEL_START     (1 << 0)
 795 #define LABEL_END       (1 << 1)
 796 #define LABEL_HYPHEN    (1 << 2)
 797 #define LABEL_IDNA      (1 << 3)
 798
 799 static const unsigned char *valid_star(const unsigned char *p, size_t len,
 800                                        unsigned int flags)
 801 {
 802     const unsigned char *star = 0;
 803     size_t i;
 804     int state = LABEL_START;
 805     int dots = 0;
 806     for (i = 0; i < len; ++i) {
 807         /*
 808          * Locate first and only legal wildcard, either at the start
 809          * or end of a non-IDNA first and not final label.
 810          */
 811         if (p[i] == '*') {
 812             int atstart = (state & LABEL_START);
 813             int atend = (i == len - 1 || p[i + 1] == '.');
 814             /*-
 815              * At most one wildcard per pattern.
 816              * No wildcards in IDNA labels.
 817              * No wildcards after the first label.
 818              */
 819             if (star != NULL || (state & LABEL_IDNA) != 0 || dots)
 820                 return NULL;
 821             /* Only full-label '*.example.com' wildcards? */
 822             if ((flags & X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS)
 823                 && (!atstart || !atend))
 824                 return NULL;
 825             /* No 'foo*bar' wildcards */
 826             if (!atstart && !atend)
 827                 return NULL;
 828             star = &p[i];
 829             state &= ~LABEL_START;
 830         } else if (('a' <= p[i] && p[i] <= 'z')
 831                    || ('A' <= p[i] && p[i] <= 'Z')
 832                    || ('0' <= p[i] && p[i] <= '9')) {
 833             if ((state & LABEL_START) != 0
 834                 && len - i >= 4 && strncasecmp((char *)&p[i], "xn--", 4) == 0)
 835                 state |= LABEL_IDNA;
 836             state &= ~(LABEL_HYPHEN | LABEL_START);
 837         } else if (p[i] == '.') {
 838             if ((state & (LABEL_HYPHEN | LABEL_START)) != 0)
 839                 return NULL;
 840             state = LABEL_START;
 841             ++dots;
 842         } else if (p[i] == '-') {
 843             /* no domain/subdomain starts with '-' */
 844             if ((state & LABEL_START) != 0)
 845                 return NULL;
 846             state |= LABEL_HYPHEN;
 847         } else
 848             return NULL;
 849     }
 850
 851     /*
 852      * The final label must not end in a hyphen or ".", and
 853      * there must be at least two dots after the star.
 854      */
 855     if ((state & (LABEL_START | LABEL_HYPHEN)) != 0 || dots < 2)
 856         return NULL;
 857     return star;
 858 }
 859
 860 /* Compare using wildcards. */
 861 static int equal_wildcard(const unsigned char *pattern, size_t pattern_len,
 862                           const unsigned char *subject, size_t subject_len,
 863                           unsigned int flags)
 864 {
 865     const unsigned char *star = NULL;
 866
 867     /*
 868      * Subject names starting with '.' can only match a wildcard pattern
 869      * via a subject sub-domain pattern suffix match.
 870      */
 871     if (!(subject_len > 1 && subject[0] == '.'))
 872         star = valid_star(pattern, pattern_len, flags);
 873     if (star == NULL)
 874         return equal_nocase(pattern, pattern_len,
 875                             subject, subject_len, flags);
 876     return wildcard_match(pattern, star - pattern,
 877                           star + 1, (pattern + pattern_len) - star - 1,
 878                           subject, subject_len, flags);
 879 }
 880
 881 /*
 882  * Compare an ASN1_STRING to a supplied string. If they match return 1. If
 883  * cmp_type > 0 only compare if string matches the type, otherwise convert it
 884  * to UTF8.
 885  */
 886
 887 static int do_check_string(ASN1_STRING *a, int cmp_type, equal_fn equal,
 888                            unsigned int flags, const char *b, size_t blen,
 889                            char **peername)
 890 {
 891     int rv = 0;
 892
 893     if (!a->data || !a->length)
 894         return 0;
 895     if (cmp_type > 0) {
 896         if (cmp_type != a->type)
 897             return 0;
 898         if (cmp_type == V_ASN1_IA5STRING)
 899             rv = equal(a->data, a->length, (unsigned char *)b, blen, flags);
 900         else if (a->length == (int)blen && !memcmp(a->data, b, blen))
 901             rv = 1;
 902         if (rv > 0 && peername)
 903             *peername = OPENSSL_strndup((char *)a->data, a->length);
 904     } else {
 905         int astrlen;
 906         unsigned char *astr;
 907         astrlen = ASN1_STRING_to_UTF8(&astr, a);
 908         if (astrlen < 0) {
 909             /*
 910              * -1 could be an internal malloc failure or a decoding error from
 911              * malformed input; we can't distinguish.
 912              */
 913             return -1;
 914         }
 915         rv = equal(astr, astrlen, (unsigned char *)b, blen, flags);
 916         if (rv > 0 && peername)
 917             *peername = OPENSSL_strndup((char *)astr, astrlen);
 918         OPENSSL_free(astr);
 919     }
 920     return rv;
 921 }
 922
 923 static int do_x509_check(X509 *x, const char *chk, size_t chklen,
 924                          unsigned int flags, int check_type, char **peername)
 925 {
 926     GENERAL_NAMES *gens = NULL;
 927     X509_NAME *name = NULL;
 928     int i;
 929     int cnid = NID_undef;
 930     int alt_type;
 931     int san_present = 0;
 932     int rv = 0;
 933     equal_fn equal;
 934
 935     /* See below, this flag is internal-only */
 936     flags &= ~_X509_CHECK_FLAG_DOT_SUBDOMAINS;
 937     if (check_type == GEN_EMAIL) {
 938         cnid = NID_pkcs9_emailAddress;
 939         alt_type = V_ASN1_IA5STRING;
 940         equal = equal_email;
 941     } else if (check_type == GEN_DNS) {
 942         cnid = NID_commonName;
 943         /* Implicit client-side DNS sub-domain pattern */
 944         if (chklen > 1 && chk[0] == '.')
 945             flags |= _X509_CHECK_FLAG_DOT_SUBDOMAINS;
 946         alt_type = V_ASN1_IA5STRING;
 947         if (flags & X509_CHECK_FLAG_NO_WILDCARDS)
 948             equal = equal_nocase;
 949         else
 950             equal = equal_wildcard;
 951     } else {
 952         alt_type = V_ASN1_OCTET_STRING;
 953         equal = equal_case;
 954     }
 955
 956     if (chklen == 0)
 957         chklen = strlen(chk);
 958
 959     gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
 960     if (gens) {
 961         for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
 962             GENERAL_NAME *gen;
 963             ASN1_STRING *cstr;
 964             gen = sk_GENERAL_NAME_value(gens, i);
 965             if (gen->type != check_type)
 966                 continue;
 967             san_present = 1;
 968             if (check_type == GEN_EMAIL)
 969                 cstr = gen->d.rfc822Name;
 970             else if (check_type == GEN_DNS)
 971                 cstr = gen->d.dNSName;
 972             else
 973                 cstr = gen->d.iPAddress;
 974             /* Positive on success, negative on error! */
 975             if ((rv = do_check_string(cstr, alt_type, equal, flags,
 976                                       chk, chklen, peername)) != 0)
 977                 break;
 978         }
 979         GENERAL_NAMES_free(gens);
 980         if (rv != 0)
 981             return rv;
 982         if (cnid == NID_undef
 983             || (san_present
 984                 && !(flags & X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT)))
 985             return 0;
 986     }
 987
 988     /* We're done if CN-ID is not pertinent */
 989     if (cnid == NID_undef)
 990         return 0;
 991
 992     i = -1;
 993     name = X509_get_subject_name(x);
 994     while ((i = X509_NAME_get_index_by_NID(name, cnid, i)) >= 0) {
 995         X509_NAME_ENTRY *ne;
 996         ASN1_STRING *str;
 997         ne = X509_NAME_get_entry(name, i);
 998         str = X509_NAME_ENTRY_get_data(ne);
 999         /* Positive on success, negative on error! */
1000         if ((rv = do_check_string(str, -1, equal, flags,
1001                                   chk, chklen, peername)) != 0)
1002             return rv;
1003     }
1004     return 0;
1005 }
1006
1007 int X509_check_host(X509 *x, const char *chk, size_t chklen,
1008                     unsigned int flags, char **peername)
1009 {
1010     if (chk == NULL)
1011         return -2;
1012     /*
1013      * Embedded NULs are disallowed, except as the last character of a
1014      * string of length 2 or more (tolerate caller including terminating
1015      * NUL in string length).
1016      */
1017     if (chklen == 0)
1018         chklen = strlen(chk);
1019     else if (memchr(chk, '\0', chklen > 1 ? chklen - 1 : chklen))
1020         return -2;
1021     if (chklen > 1 && chk[chklen - 1] == '\0')
1022         --chklen;
1023     return do_x509_check(x, chk, chklen, flags, GEN_DNS, peername);
1024 }
1025
1026 int X509_check_email(X509 *x, const char *chk, size_t chklen,
1027                      unsigned int flags)
1028 {
1029     if (chk == NULL)
1030         return -2;
1031     /*
1032      * Embedded NULs are disallowed, except as the last character of a
1033      * string of length 2 or more (tolerate caller including terminating
1034      * NUL in string length).
1035      */
1036     if (chklen == 0)
1037         chklen = strlen((char *)chk);
1038     else if (memchr(chk, '\0', chklen > 1 ? chklen - 1 : chklen))
1039         return -2;
1040     if (chklen > 1 && chk[chklen - 1] == '\0')
1041         --chklen;
1042     return do_x509_check(x, chk, chklen, flags, GEN_EMAIL, NULL);
1043 }
1044
1045 int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
1046                   unsigned int flags)
1047 {
1048     if (chk == NULL)
1049         return -2;
1050     return do_x509_check(x, (char *)chk, chklen, flags, GEN_IPADD, NULL);
1051 }
1052
1053 int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags)
1054 {
1055     unsigned char ipout[16];
1056     size_t iplen;
1057
1058     if (ipasc == NULL)
1059         return -2;
1060     iplen = (size_t)a2i_ipadd(ipout, ipasc);
1061     if (iplen == 0)
1062         return -2;
1063     return do_x509_check(x, (char *)ipout, iplen, flags, GEN_IPADD, NULL);
1064 }
1065
1066 /*
1067  * Convert IP addresses both IPv4 and IPv6 into an OCTET STRING compatible
1068  * with RFC3280.
1069  */
1070
1071 ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc)
1072 {
1073     unsigned char ipout[16];
1074     ASN1_OCTET_STRING *ret;
1075     int iplen;
1076
1077     /* If string contains a ':' assume IPv6 */
1078
1079     iplen = a2i_ipadd(ipout, ipasc);
1080
1081     if (!iplen)
1082         return NULL;
1083
1084     ret = ASN1_OCTET_STRING_new();
1085     if (ret == NULL)
1086         return NULL;
1087     if (!ASN1_OCTET_STRING_set(ret, ipout, iplen)) {
1088         ASN1_OCTET_STRING_free(ret);
1089         return NULL;
1090     }
1091     return ret;
1092 }
1093
1094 ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc)
1095 {
1096     ASN1_OCTET_STRING *ret = NULL;
1097     unsigned char ipout[32];
1098     char *iptmp = NULL, *p;
1099     int iplen1, iplen2;
1100     p = strchr(ipasc, '/');
1101     if (!p)
1102         return NULL;
1103     iptmp = OPENSSL_strdup(ipasc);
1104     if (!iptmp)
1105         return NULL;
1106     p = iptmp + (p - ipasc);
1107     *p++ = 0;
1108
1109     iplen1 = a2i_ipadd(ipout, iptmp);
1110
1111     if (!iplen1)
1112         goto err;
1113
1114     iplen2 = a2i_ipadd(ipout + iplen1, p);
1115
1116     OPENSSL_free(iptmp);
1117     iptmp = NULL;
1118
1119     if (!iplen2 || (iplen1 != iplen2))
1120         goto err;
1121
1122     ret = ASN1_OCTET_STRING_new();
1123     if (ret == NULL)
1124         goto err;
1125     if (!ASN1_OCTET_STRING_set(ret, ipout, iplen1 + iplen2))
1126         goto err;
1127
1128     return ret;
1129
1130  err:
1131     OPENSSL_free(iptmp);
1132     ASN1_OCTET_STRING_free(ret);
1133     return NULL;
1134 }
1135
1136 int a2i_ipadd(unsigned char *ipout, const char *ipasc)
1137 {
1138     /* If string contains a ':' assume IPv6 */
1139
1140     if (strchr(ipasc, ':')) {
1141         if (!ipv6_from_asc(ipout, ipasc))
1142             return 0;
1143         return 16;
1144     } else {
1145         if (!ipv4_from_asc(ipout, ipasc))
1146             return 0;
1147         return 4;
1148     }
1149 }
1150
1151 static int ipv4_from_asc(unsigned char *v4, const char *in)
1152 {
1153     int a0, a1, a2, a3;
1154     if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
1155         return 0;
1156     if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
1157         || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
1158         return 0;
1159     v4[0] = a0;
1160     v4[1] = a1;
1161     v4[2] = a2;
1162     v4[3] = a3;
1163     return 1;
1164 }
1165
1166 typedef struct {
1167     /* Temporary store for IPV6 output */
1168     unsigned char tmp[16];
1169     /* Total number of bytes in tmp */
1170     int total;
1171     /* The position of a zero (corresponding to '::') */
1172     int zero_pos;
1173     /* Number of zeroes */
1174     int zero_cnt;
1175 } IPV6_STAT;
1176
1177 static int ipv6_from_asc(unsigned char *v6, const char *in)
1178 {
1179     IPV6_STAT v6stat;
1180     v6stat.total = 0;
1181     v6stat.zero_pos = -1;
1182     v6stat.zero_cnt = 0;
1183     /*
1184      * Treat the IPv6 representation as a list of values separated by ':'.
1185      * The presence of a '::' will parse as one, two or three zero length
1186      * elements.
1187      */
1188     if (!CONF_parse_list(in, ':', 0, ipv6_cb, &v6stat))
1189         return 0;
1190
1191     /* Now for some sanity checks */
1192
1193     if (v6stat.zero_pos == -1) {
1194         /* If no '::' must have exactly 16 bytes */
1195         if (v6stat.total != 16)
1196             return 0;
1197     } else {
1198         /* If '::' must have less than 16 bytes */
1199         if (v6stat.total == 16)
1200             return 0;
1201         /* More than three zeroes is an error */
1202         if (v6stat.zero_cnt > 3)
1203             return 0;
1204         /* Can only have three zeroes if nothing else present */
1205         else if (v6stat.zero_cnt == 3) {
1206             if (v6stat.total > 0)
1207                 return 0;
1208         }
1209         /* Can only have two zeroes if at start or end */
1210         else if (v6stat.zero_cnt == 2) {
1211             if ((v6stat.zero_pos != 0)
1212                 && (v6stat.zero_pos != v6stat.total))
1213                 return 0;
1214         } else
1215             /* Can only have one zero if *not* start or end */
1216         {
1217             if ((v6stat.zero_pos == 0)
1218                 || (v6stat.zero_pos == v6stat.total))
1219                 return 0;
1220         }
1221     }
1222
1223     /* Format result */
1224
1225     if (v6stat.zero_pos >= 0) {
1226         /* Copy initial part */
1227         memcpy(v6, v6stat.tmp, v6stat.zero_pos);
1228         /* Zero middle */
1229         memset(v6 + v6stat.zero_pos, 0, 16 - v6stat.total);
1230         /* Copy final part */
1231         if (v6stat.total != v6stat.zero_pos)
1232             memcpy(v6 + v6stat.zero_pos + 16 - v6stat.total,
1233                    v6stat.tmp + v6stat.zero_pos,
1234                    v6stat.total - v6stat.zero_pos);
1235     } else
1236         memcpy(v6, v6stat.tmp, 16);
1237
1238     return 1;
1239 }
1240
1241 static int ipv6_cb(const char *elem, int len, void *usr)
1242 {
1243     IPV6_STAT *s = usr;
1244     /* Error if 16 bytes written */
1245     if (s->total == 16)
1246         return 0;
1247     if (len == 0) {
1248         /* Zero length element, corresponds to '::' */
1249         if (s->zero_pos == -1)
1250             s->zero_pos = s->total;
1251         /* If we've already got a :: its an error */
1252         else if (s->zero_pos != s->total)
1253             return 0;
1254         s->zero_cnt++;
1255     } else {
1256         /* If more than 4 characters could be final a.b.c.d form */
1257         if (len > 4) {
1258             /* Need at least 4 bytes left */
1259             if (s->total > 12)
1260                 return 0;
1261             /* Must be end of string */
1262             if (elem[len])
1263                 return 0;
1264             if (!ipv4_from_asc(s->tmp + s->total, elem))
1265                 return 0;
1266             s->total += 4;
1267         } else {
1268             if (!ipv6_hex(s->tmp + s->total, elem, len))
1269                 return 0;
1270             s->total += 2;
1271         }
1272     }
1273     return 1;
1274 }
1275
1276 /*
1277  * Convert a string of up to 4 hex digits into the corresponding IPv6 form.
1278  */
1279
1280 static int ipv6_hex(unsigned char *out, const char *in, int inlen)
1281 {
1282     unsigned char c;
1283     unsigned int num = 0;
1284     if (inlen > 4)
1285         return 0;
1286     while (inlen--) {
1287         c = *in++;
1288         num <<= 4;
1289         if ((c >= '0') && (c <= '9'))
1290             num |= c - '0';
1291         else if ((c >= 'A') && (c <= 'F'))
1292             num |= c - 'A' + 10;
1293         else if ((c >= 'a') && (c <= 'f'))
1294             num |= c - 'a' + 10;
1295         else
1296             return 0;
1297     }
1298     out[0] = num >> 8;
1299     out[1] = num & 0xff;
1300     return 1;
1301 }
1302
1303 int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE) *dn_sk,
1304                              unsigned long chtype)
1305 {
1306     CONF_VALUE *v;
1307     int i, mval;
1308     char *p, *type;
1309     if (!nm)
1310         return 0;
1311
1312     for (i = 0; i < sk_CONF_VALUE_num(dn_sk); i++) {
1313         v = sk_CONF_VALUE_value(dn_sk, i);
1314         type = v->name;
1315         /*
1316          * Skip past any leading X. X: X, etc to allow for multiple instances
1317          */
1318         for (p = type; *p; p++)
1319 #ifndef CHARSET_EBCDIC
1320             if ((*p == ':') || (*p == ',') || (*p == '.'))
1321 #else
1322             if ((*p == os_toascii[':']) || (*p == os_toascii[','])
1323                 || (*p == os_toascii['.']))
1324 #endif
1325             {
1326                 p++;
1327                 if (*p)
1328                     type = p;
1329                 break;
1330             }
1331 #ifndef CHARSET_EBCDIC
1332         if (*type == '+')
1333 #else
1334         if (*type == os_toascii['+'])
1335 #endif
1336         {
1337             mval = -1;
1338             type++;
1339         } else
1340             mval = 0;
1341         if (!X509_NAME_add_entry_by_txt(nm, type, chtype,
1342                                         (unsigned char *)v->value, -1, -1,
1343                                         mval))
1344             return 0;
1345
1346     }
1347     return 1;
1348 }