crypto/x509/v3_utl.c

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