crypto/x509v3/v3_utl.c

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