crypto/x509/v3_utl.c

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