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