crypto/asn1/tasn_dec.c

   1 /*
   2  * Copyright 2000-2016 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 #include <stddef.h>
  11 #include <string.h>
  12 #include <openssl/asn1.h>
  13 #include <openssl/asn1t.h>
  14 #include <openssl/objects.h>
  15 #include <openssl/buffer.h>
  16 #include <openssl/err.h>
  17 #include "internal/numbers.h"
  18 #include "asn1_locl.h"
  19
  20 static int asn1_item_embed_d2i(ASN1_VALUE **pval, const unsigned char **in,
  21                                long len, const ASN1_ITEM *it,
  22                                int tag, int aclass, char opt, ASN1_TLC *ctx);
  23
  24 static int asn1_check_eoc(const unsigned char **in, long len);
  25 static int asn1_find_end(const unsigned char **in, long len, char inf);
  26
  27 static int asn1_collect(BUF_MEM *buf, const unsigned char **in, long len,
  28                         char inf, int tag, int aclass, int depth);
  29
  30 static int collect_data(BUF_MEM *buf, const unsigned char **p, long plen);
  31
  32 static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass,
  33                            char *inf, char *cst,
  34                            const unsigned char **in, long len,
  35                            int exptag, int expclass, char opt, ASN1_TLC *ctx);
  36
  37 static int asn1_template_ex_d2i(ASN1_VALUE **pval,
  38                                 const unsigned char **in, long len,
  39                                 const ASN1_TEMPLATE *tt, char opt,
  40                                 ASN1_TLC *ctx);
  41 static int asn1_template_noexp_d2i(ASN1_VALUE **val,
  42                                    const unsigned char **in, long len,
  43                                    const ASN1_TEMPLATE *tt, char opt,
  44                                    ASN1_TLC *ctx);
  45 static int asn1_d2i_ex_primitive(ASN1_VALUE **pval,
  46                                  const unsigned char **in, long len,
  47                                  const ASN1_ITEM *it,
  48                                  int tag, int aclass, char opt,
  49                                  ASN1_TLC *ctx);
  50 static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
  51                        int utype, char *free_cont, const ASN1_ITEM *it);
  52
  53 /* Table to convert tags to bit values, used for MSTRING type */
  54 static const unsigned long tag2bit[32] = {
  55     /* tags  0 -  3 */
  56     0, 0, 0, B_ASN1_BIT_STRING,
  57     /* tags  4- 7 */
  58     B_ASN1_OCTET_STRING, 0, 0, B_ASN1_UNKNOWN,
  59     /* tags  8-11 */
  60     B_ASN1_UNKNOWN, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN,
  61     /* tags 12-15 */
  62     B_ASN1_UTF8STRING, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN,
  63     /* tags 16-19 */
  64     B_ASN1_SEQUENCE, 0, B_ASN1_NUMERICSTRING, B_ASN1_PRINTABLESTRING,
  65     /* tags 20-22 */
  66     B_ASN1_T61STRING, B_ASN1_VIDEOTEXSTRING, B_ASN1_IA5STRING,
  67     /* tags 23-24 */
  68     B_ASN1_UTCTIME, B_ASN1_GENERALIZEDTIME,
  69     /* tags 25-27 */
  70     B_ASN1_GRAPHICSTRING, B_ASN1_ISO64STRING, B_ASN1_GENERALSTRING,
  71     /* tags 28-31 */
  72     B_ASN1_UNIVERSALSTRING, B_ASN1_UNKNOWN, B_ASN1_BMPSTRING, B_ASN1_UNKNOWN,
  73 };
  74
  75 unsigned long ASN1_tag2bit(int tag)
  76 {
  77     if ((tag < 0) || (tag > 30))
  78         return 0;
  79     return tag2bit[tag];
  80 }
  81
  82 /* Macro to initialize and invalidate the cache */
  83
  84 #define asn1_tlc_clear(c)       if (c) (c)->valid = 0
  85 /* Version to avoid compiler warning about 'c' always non-NULL */
  86 #define asn1_tlc_clear_nc(c)    (c)->valid = 0
  87
  88 /*
  89  * Decode an ASN1 item, this currently behaves just like a standard 'd2i'
  90  * function. 'in' points to a buffer to read the data from, in future we
  91  * will have more advanced versions that can input data a piece at a time and
  92  * this will simply be a special case.
  93  */
  94
  95 ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **pval,
  96                           const unsigned char **in, long len,
  97                           const ASN1_ITEM *it)
  98 {
  99     ASN1_TLC c;
 100     ASN1_VALUE *ptmpval = NULL;
 101     if (!pval)
 102         pval = &ptmpval;
 103     asn1_tlc_clear_nc(&c);
 104     if (ASN1_item_ex_d2i(pval, in, len, it, -1, 0, 0, &c) > 0)
 105         return *pval;
 106     return NULL;
 107 }
 108
 109 int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
 110                      const ASN1_ITEM *it,
 111                      int tag, int aclass, char opt, ASN1_TLC *ctx)
 112 {
 113     int rv;
 114     rv = asn1_item_embed_d2i(pval, in, len, it, tag, aclass, opt, ctx);
 115     if (rv <= 0)
 116         ASN1_item_ex_free(pval, it);
 117     return rv;
 118 }
 119
 120 /*
 121  * Decode an item, taking care of IMPLICIT tagging, if any. If 'opt' set and
 122  * tag mismatch return -1 to handle OPTIONAL
 123  */
 124
 125 static int asn1_item_embed_d2i(ASN1_VALUE **pval, const unsigned char **in,
 126                                long len, const ASN1_ITEM *it,
 127                                int tag, int aclass, char opt, ASN1_TLC *ctx)
 128 {
 129     const ASN1_TEMPLATE *tt, *errtt = NULL;
 130     const ASN1_EXTERN_FUNCS *ef;
 131     const ASN1_AUX *aux = it->funcs;
 132     ASN1_aux_cb *asn1_cb;
 133     const unsigned char *p = NULL, *q;
 134     unsigned char oclass;
 135     char seq_eoc, seq_nolen, cst, isopt;
 136     long tmplen;
 137     int i;
 138     int otag;
 139     int ret = 0;
 140     ASN1_VALUE **pchptr;
 141     if (!pval)
 142         return 0;
 143     if (aux && aux->asn1_cb)
 144         asn1_cb = aux->asn1_cb;
 145     else
 146         asn1_cb = 0;
 147
 148     switch (it->itype) {
 149     case ASN1_ITYPE_PRIMITIVE:
 150         if (it->templates) {
 151             /*
 152              * tagging or OPTIONAL is currently illegal on an item template
 153              * because the flags can't get passed down. In practice this
 154              * isn't a problem: we include the relevant flags from the item
 155              * template in the template itself.
 156              */
 157             if ((tag != -1) || opt) {
 158                 ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I,
 159                         ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE);
 160                 goto err;
 161             }
 162             return asn1_template_ex_d2i(pval, in, len,
 163                                         it->templates, opt, ctx);
 164         }
 165         return asn1_d2i_ex_primitive(pval, in, len, it,
 166                                      tag, aclass, opt, ctx);
 167
 168     case ASN1_ITYPE_MSTRING:
 169         p = *in;
 170         /* Just read in tag and class */
 171         ret = asn1_check_tlen(NULL, &otag, &oclass, NULL, NULL,
 172                               &p, len, -1, 0, 1, ctx);
 173         if (!ret) {
 174             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ERR_R_NESTED_ASN1_ERROR);
 175             goto err;
 176         }
 177
 178         /* Must be UNIVERSAL class */
 179         if (oclass != V_ASN1_UNIVERSAL) {
 180             /* If OPTIONAL, assume this is OK */
 181             if (opt)
 182                 return -1;
 183             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_MSTRING_NOT_UNIVERSAL);
 184             goto err;
 185         }
 186         /* Check tag matches bit map */
 187         if (!(ASN1_tag2bit(otag) & it->utype)) {
 188             /* If OPTIONAL, assume this is OK */
 189             if (opt)
 190                 return -1;
 191             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_MSTRING_WRONG_TAG);
 192             goto err;
 193         }
 194         return asn1_d2i_ex_primitive(pval, in, len, it, otag, 0, 0, ctx);
 195
 196     case ASN1_ITYPE_EXTERN:
 197         /* Use new style d2i */
 198         ef = it->funcs;
 199         return ef->asn1_ex_d2i(pval, in, len, it, tag, aclass, opt, ctx);
 200
 201     case ASN1_ITYPE_CHOICE:
 202         if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL))
 203             goto auxerr;
 204         if (*pval) {
 205             /* Free up and zero CHOICE value if initialised */
 206             i = asn1_get_choice_selector(pval, it);
 207             if ((i >= 0) && (i < it->tcount)) {
 208                 tt = it->templates + i;
 209                 pchptr = asn1_get_field_ptr(pval, tt);
 210                 asn1_template_free(pchptr, tt);
 211                 asn1_set_choice_selector(pval, -1, it);
 212             }
 213         } else if (!ASN1_item_ex_new(pval, it)) {
 214             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ERR_R_NESTED_ASN1_ERROR);
 215             goto err;
 216         }
 217         /* CHOICE type, try each possibility in turn */
 218         p = *in;
 219         for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
 220             pchptr = asn1_get_field_ptr(pval, tt);
 221             /*
 222              * We mark field as OPTIONAL so its absence can be recognised.
 223              */
 224             ret = asn1_template_ex_d2i(pchptr, &p, len, tt, 1, ctx);
 225             /* If field not present, try the next one */
 226             if (ret == -1)
 227                 continue;
 228             /*
 229              * Set the choice selector here to ensure that the value is
 230              * correctly freed upon error. It may be partially initialized
 231              * even if parsing failed.
 232              */
 233             asn1_set_choice_selector(pval, i, it);
 234             /* If positive return, read OK, break loop */
 235             if (ret > 0)
 236                 break;
 237             /* Otherwise must be an ASN1 parsing error */
 238             errtt = tt;
 239             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ERR_R_NESTED_ASN1_ERROR);
 240             goto err;
 241         }
 242
 243         /* Did we fall off the end without reading anything? */
 244         if (i == it->tcount) {
 245             /* If OPTIONAL, this is OK */
 246             if (opt) {
 247                 /* Free and zero it */
 248                 ASN1_item_ex_free(pval, it);
 249                 return -1;
 250             }
 251             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_NO_MATCHING_CHOICE_TYPE);
 252             goto err;
 253         }
 254
 255         if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL))
 256             goto auxerr;
 257         *in = p;
 258         return 1;
 259
 260     case ASN1_ITYPE_NDEF_SEQUENCE:
 261     case ASN1_ITYPE_SEQUENCE:
 262         p = *in;
 263         tmplen = len;
 264
 265         /* If no IMPLICIT tagging set to SEQUENCE, UNIVERSAL */
 266         if (tag == -1) {
 267             tag = V_ASN1_SEQUENCE;
 268             aclass = V_ASN1_UNIVERSAL;
 269         }
 270         /* Get SEQUENCE length and update len, p */
 271         ret = asn1_check_tlen(&len, NULL, NULL, &seq_eoc, &cst,
 272                               &p, len, tag, aclass, opt, ctx);
 273         if (!ret) {
 274             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ERR_R_NESTED_ASN1_ERROR);
 275             goto err;
 276         } else if (ret == -1)
 277             return -1;
 278         if (aux && (aux->flags & ASN1_AFLG_BROKEN)) {
 279             len = tmplen - (p - *in);
 280             seq_nolen = 1;
 281         }
 282         /* If indefinite we don't do a length check */
 283         else
 284             seq_nolen = seq_eoc;
 285         if (!cst) {
 286             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_SEQUENCE_NOT_CONSTRUCTED);
 287             goto err;
 288         }
 289
 290         if (!*pval && !ASN1_item_ex_new(pval, it)) {
 291             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ERR_R_NESTED_ASN1_ERROR);
 292             goto err;
 293         }
 294
 295         if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL))
 296             goto auxerr;
 297
 298         /* Free up and zero any ADB found */
 299         for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
 300             if (tt->flags & ASN1_TFLG_ADB_MASK) {
 301                 const ASN1_TEMPLATE *seqtt;
 302                 ASN1_VALUE **pseqval;
 303                 seqtt = asn1_do_adb(pval, tt, 1);
 304                 pseqval = asn1_get_field_ptr(pval, seqtt);
 305                 asn1_template_free(pseqval, seqtt);
 306             }
 307         }
 308
 309         /* Get each field entry */
 310         for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
 311             const ASN1_TEMPLATE *seqtt;
 312             ASN1_VALUE **pseqval;
 313             seqtt = asn1_do_adb(pval, tt, 1);
 314             if (!seqtt)
 315                 goto err;
 316             pseqval = asn1_get_field_ptr(pval, seqtt);
 317             /* Have we ran out of data? */
 318             if (!len)
 319                 break;
 320             q = p;
 321             if (asn1_check_eoc(&p, len)) {
 322                 if (!seq_eoc) {
 323                     ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_UNEXPECTED_EOC);
 324                     goto err;
 325                 }
 326                 len -= p - q;
 327                 seq_eoc = 0;
 328                 q = p;
 329                 break;
 330             }
 331             /*
 332              * This determines the OPTIONAL flag value. The field cannot be
 333              * omitted if it is the last of a SEQUENCE and there is still
 334              * data to be read. This isn't strictly necessary but it
 335              * increases efficiency in some cases.
 336              */
 337             if (i == (it->tcount - 1))
 338                 isopt = 0;
 339             else
 340                 isopt = (char)(seqtt->flags & ASN1_TFLG_OPTIONAL);
 341             /*
 342              * attempt to read in field, allowing each to be OPTIONAL
 343              */
 344
 345             ret = asn1_template_ex_d2i(pseqval, &p, len, seqtt, isopt, ctx);
 346             if (!ret) {
 347                 errtt = seqtt;
 348                 goto err;
 349             } else if (ret == -1) {
 350                 /*
 351                  * OPTIONAL component absent. Free and zero the field.
 352                  */
 353                 asn1_template_free(pseqval, seqtt);
 354                 continue;
 355             }
 356             /* Update length */
 357             len -= p - q;
 358         }
 359
 360         /* Check for EOC if expecting one */
 361         if (seq_eoc && !asn1_check_eoc(&p, len)) {
 362             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_MISSING_EOC);
 363             goto err;
 364         }
 365         /* Check all data read */
 366         if (!seq_nolen && len) {
 367             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_SEQUENCE_LENGTH_MISMATCH);
 368             goto err;
 369         }
 370
 371         /*
 372          * If we get here we've got no more data in the SEQUENCE, however we
 373          * may not have read all fields so check all remaining are OPTIONAL
 374          * and clear any that are.
 375          */
 376         for (; i < it->tcount; tt++, i++) {
 377             const ASN1_TEMPLATE *seqtt;
 378             seqtt = asn1_do_adb(pval, tt, 1);
 379             if (!seqtt)
 380                 goto err;
 381             if (seqtt->flags & ASN1_TFLG_OPTIONAL) {
 382                 ASN1_VALUE **pseqval;
 383                 pseqval = asn1_get_field_ptr(pval, seqtt);
 384                 asn1_template_free(pseqval, seqtt);
 385             } else {
 386                 errtt = seqtt;
 387                 ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_FIELD_MISSING);
 388                 goto err;
 389             }
 390         }
 391         /* Save encoding */
 392         if (!asn1_enc_save(pval, *in, p - *in, it))
 393             goto auxerr;
 394         if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL))
 395             goto auxerr;
 396         *in = p;
 397         return 1;
 398
 399     default:
 400         return 0;
 401     }
 402  auxerr:
 403     ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_AUX_ERROR);
 404  err:
 405     if (errtt)
 406         ERR_add_error_data(4, "Field=", errtt->field_name,
 407                            ", Type=", it->sname);
 408     else
 409         ERR_add_error_data(2, "Type=", it->sname);
 410     return 0;
 411 }
 412
 413 /*
 414  * Templates are handled with two separate functions. One handles any
 415  * EXPLICIT tag and the other handles the rest.
 416  */
 417
 418 static int asn1_template_ex_d2i(ASN1_VALUE **val,
 419                                 const unsigned char **in, long inlen,
 420                                 const ASN1_TEMPLATE *tt, char opt,
 421                                 ASN1_TLC *ctx)
 422 {
 423     int flags, aclass;
 424     int ret;
 425     long len;
 426     const unsigned char *p, *q;
 427     char exp_eoc;
 428     if (!val)
 429         return 0;
 430     flags = tt->flags;
 431     aclass = flags & ASN1_TFLG_TAG_CLASS;
 432
 433     p = *in;
 434
 435     /* Check if EXPLICIT tag expected */
 436     if (flags & ASN1_TFLG_EXPTAG) {
 437         char cst;
 438         /*
 439          * Need to work out amount of data available to the inner content and
 440          * where it starts: so read in EXPLICIT header to get the info.
 441          */
 442         ret = asn1_check_tlen(&len, NULL, NULL, &exp_eoc, &cst,
 443                               &p, inlen, tt->tag, aclass, opt, ctx);
 444         q = p;
 445         if (!ret) {
 446             ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_NESTED_ASN1_ERROR);
 447             return 0;
 448         } else if (ret == -1)
 449             return -1;
 450         if (!cst) {
 451             ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I,
 452                     ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED);
 453             return 0;
 454         }
 455         /* We've found the field so it can't be OPTIONAL now */
 456         ret = asn1_template_noexp_d2i(val, &p, len, tt, 0, ctx);
 457         if (!ret) {
 458             ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_NESTED_ASN1_ERROR);
 459             return 0;
 460         }
 461         /* We read the field in OK so update length */
 462         len -= p - q;
 463         if (exp_eoc) {
 464             /* If NDEF we must have an EOC here */
 465             if (!asn1_check_eoc(&p, len)) {
 466                 ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ASN1_R_MISSING_EOC);
 467                 goto err;
 468             }
 469         } else {
 470             /*
 471              * Otherwise we must hit the EXPLICIT tag end or its an error
 472              */
 473             if (len) {
 474                 ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I,
 475                         ASN1_R_EXPLICIT_LENGTH_MISMATCH);
 476                 goto err;
 477             }
 478         }
 479     } else
 480         return asn1_template_noexp_d2i(val, in, inlen, tt, opt, ctx);
 481
 482     *in = p;
 483     return 1;
 484
 485  err:
 486     return 0;
 487 }
 488
 489 static int asn1_template_noexp_d2i(ASN1_VALUE **val,
 490                                    const unsigned char **in, long len,
 491                                    const ASN1_TEMPLATE *tt, char opt,
 492                                    ASN1_TLC *ctx)
 493 {
 494     int flags, aclass;
 495     int ret;
 496     ASN1_VALUE *tval;
 497     const unsigned char *p, *q;
 498     if (!val)
 499         return 0;
 500     flags = tt->flags;
 501     aclass = flags & ASN1_TFLG_TAG_CLASS;
 502
 503     p = *in;
 504     q = p;
 505
 506     /*
 507      * If field is embedded then val needs fixing so it is a pointer to
 508      * a pointer to a field.
 509      */
 510     if (tt->flags & ASN1_TFLG_EMBED) {
 511         tval = (ASN1_VALUE *)val;
 512         val = &tval;
 513     }
 514
 515     if (flags & ASN1_TFLG_SK_MASK) {
 516         /* SET OF, SEQUENCE OF */
 517         int sktag, skaclass;
 518         char sk_eoc;
 519         /* First work out expected inner tag value */
 520         if (flags & ASN1_TFLG_IMPTAG) {
 521             sktag = tt->tag;
 522             skaclass = aclass;
 523         } else {
 524             skaclass = V_ASN1_UNIVERSAL;
 525             if (flags & ASN1_TFLG_SET_OF)
 526                 sktag = V_ASN1_SET;
 527             else
 528                 sktag = V_ASN1_SEQUENCE;
 529         }
 530         /* Get the tag */
 531         ret = asn1_check_tlen(&len, NULL, NULL, &sk_eoc, NULL,
 532                               &p, len, sktag, skaclass, opt, ctx);
 533         if (!ret) {
 534             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
 535             return 0;
 536         } else if (ret == -1)
 537             return -1;
 538         if (!*val)
 539             *val = (ASN1_VALUE *)OPENSSL_sk_new_null();
 540         else {
 541             /*
 542              * We've got a valid STACK: free up any items present
 543              */
 544             STACK_OF(ASN1_VALUE) *sktmp = (STACK_OF(ASN1_VALUE) *)*val;
 545             ASN1_VALUE *vtmp;
 546             while (sk_ASN1_VALUE_num(sktmp) > 0) {
 547                 vtmp = sk_ASN1_VALUE_pop(sktmp);
 548                 ASN1_item_ex_free(&vtmp, ASN1_ITEM_ptr(tt->item));
 549             }
 550         }
 551
 552         if (!*val) {
 553             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_MALLOC_FAILURE);
 554             goto err;
 555         }
 556
 557         /* Read as many items as we can */
 558         while (len > 0) {
 559             ASN1_VALUE *skfield;
 560             q = p;
 561             /* See if EOC found */
 562             if (asn1_check_eoc(&p, len)) {
 563                 if (!sk_eoc) {
 564                     ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I,
 565                             ASN1_R_UNEXPECTED_EOC);
 566                     goto err;
 567                 }
 568                 len -= p - q;
 569                 sk_eoc = 0;
 570                 break;
 571             }
 572             skfield = NULL;
 573             if (!asn1_item_embed_d2i(&skfield, &p, len,
 574                                      ASN1_ITEM_ptr(tt->item), -1, 0, 0, ctx)) {
 575                 ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I,
 576                         ERR_R_NESTED_ASN1_ERROR);
 577                 /* |skfield| may be partially allocated despite failure. */
 578                 ASN1_item_free(skfield, ASN1_ITEM_ptr(tt->item));
 579                 goto err;
 580             }
 581             len -= p - q;
 582             if (!sk_ASN1_VALUE_push((STACK_OF(ASN1_VALUE) *)*val, skfield)) {
 583                 ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_MALLOC_FAILURE);
 584                 ASN1_item_free(skfield, ASN1_ITEM_ptr(tt->item));
 585                 goto err;
 586             }
 587         }
 588         if (sk_eoc) {
 589             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ASN1_R_MISSING_EOC);
 590             goto err;
 591         }
 592     } else if (flags & ASN1_TFLG_IMPTAG) {
 593         /* IMPLICIT tagging */
 594         ret = asn1_item_embed_d2i(val, &p, len,
 595                                   ASN1_ITEM_ptr(tt->item), tt->tag, aclass, opt,
 596                                   ctx);
 597         if (!ret) {
 598             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
 599             goto err;
 600         } else if (ret == -1)
 601             return -1;
 602     } else {
 603         /* Nothing special */
 604         ret = asn1_item_embed_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item),
 605                                   -1, 0, opt, ctx);
 606         if (!ret) {
 607             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
 608             goto err;
 609         } else if (ret == -1)
 610             return -1;
 611     }
 612
 613     *in = p;
 614     return 1;
 615
 616  err:
 617     return 0;
 618 }
 619
 620 static int asn1_d2i_ex_primitive(ASN1_VALUE **pval,
 621                                  const unsigned char **in, long inlen,
 622                                  const ASN1_ITEM *it,
 623                                  int tag, int aclass, char opt, ASN1_TLC *ctx)
 624 {
 625     int ret = 0, utype;
 626     long plen;
 627     char cst, inf, free_cont = 0;
 628     const unsigned char *p;
 629     BUF_MEM buf = { 0, NULL, 0, 0 };
 630     const unsigned char *cont = NULL;
 631     long len;
 632     if (!pval) {
 633         ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_NULL);
 634         return 0;               /* Should never happen */
 635     }
 636
 637     if (it->itype == ASN1_ITYPE_MSTRING) {
 638         utype = tag;
 639         tag = -1;
 640     } else
 641         utype = it->utype;
 642
 643     if (utype == V_ASN1_ANY) {
 644         /* If type is ANY need to figure out type from tag */
 645         unsigned char oclass;
 646         if (tag >= 0) {
 647             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_TAGGED_ANY);
 648             return 0;
 649         }
 650         if (opt) {
 651             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE,
 652                     ASN1_R_ILLEGAL_OPTIONAL_ANY);
 653             return 0;
 654         }
 655         p = *in;
 656         ret = asn1_check_tlen(NULL, &utype, &oclass, NULL, NULL,
 657                               &p, inlen, -1, 0, 0, ctx);
 658         if (!ret) {
 659             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_NESTED_ASN1_ERROR);
 660             return 0;
 661         }
 662         if (oclass != V_ASN1_UNIVERSAL)
 663             utype = V_ASN1_OTHER;
 664     }
 665     if (tag == -1) {
 666         tag = utype;
 667         aclass = V_ASN1_UNIVERSAL;
 668     }
 669     p = *in;
 670     /* Check header */
 671     ret = asn1_check_tlen(&plen, NULL, NULL, &inf, &cst,
 672                           &p, inlen, tag, aclass, opt, ctx);
 673     if (!ret) {
 674         ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_NESTED_ASN1_ERROR);
 675         return 0;
 676     } else if (ret == -1)
 677         return -1;
 678     ret = 0;
 679     /* SEQUENCE, SET and "OTHER" are left in encoded form */
 680     if ((utype == V_ASN1_SEQUENCE)
 681         || (utype == V_ASN1_SET) || (utype == V_ASN1_OTHER)) {
 682         /*
 683          * Clear context cache for type OTHER because the auto clear when we
 684          * have a exact match wont work
 685          */
 686         if (utype == V_ASN1_OTHER) {
 687             asn1_tlc_clear(ctx);
 688         }
 689         /* SEQUENCE and SET must be constructed */
 690         else if (!cst) {
 691             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE,
 692                     ASN1_R_TYPE_NOT_CONSTRUCTED);
 693             return 0;
 694         }
 695
 696         cont = *in;
 697         /* If indefinite length constructed find the real end */
 698         if (inf) {
 699             if (!asn1_find_end(&p, plen, inf))
 700                 goto err;
 701             len = p - cont;
 702         } else {
 703             len = p - cont + plen;
 704             p += plen;
 705         }
 706     } else if (cst) {
 707         if (utype == V_ASN1_NULL || utype == V_ASN1_BOOLEAN
 708             || utype == V_ASN1_OBJECT || utype == V_ASN1_INTEGER
 709             || utype == V_ASN1_ENUMERATED) {
 710             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_TYPE_NOT_PRIMITIVE);
 711             return 0;
 712         }
 713
 714         /* Free any returned 'buf' content */
 715         free_cont = 1;
 716         /*
 717          * Should really check the internal tags are correct but some things
 718          * may get this wrong. The relevant specs say that constructed string
 719          * types should be OCTET STRINGs internally irrespective of the type.
 720          * So instead just check for UNIVERSAL class and ignore the tag.
 721          */
 722         if (!asn1_collect(&buf, &p, plen, inf, -1, V_ASN1_UNIVERSAL, 0)) {
 723             goto err;
 724         }
 725         len = buf.length;
 726         /* Append a final null to string */
 727         if (!BUF_MEM_grow_clean(&buf, len + 1)) {
 728             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_MALLOC_FAILURE);
 729             goto err;
 730         }
 731         buf.data[len] = 0;
 732         cont = (const unsigned char *)buf.data;
 733     } else {
 734         cont = p;
 735         len = plen;
 736         p += plen;
 737     }
 738
 739     /* We now have content length and type: translate into a structure */
 740     /* asn1_ex_c2i may reuse allocated buffer, and so sets free_cont to 0 */
 741     if (!asn1_ex_c2i(pval, cont, len, utype, &free_cont, it))
 742         goto err;
 743
 744     *in = p;
 745     ret = 1;
 746  err:
 747     if (free_cont)
 748         OPENSSL_free(buf.data);
 749     return ret;
 750 }
 751
 752 /* Translate ASN1 content octets into a structure */
 753
 754 static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
 755                        int utype, char *free_cont, const ASN1_ITEM *it)
 756 {
 757     ASN1_VALUE **opval = NULL;
 758     ASN1_STRING *stmp;
 759     ASN1_TYPE *typ = NULL;
 760     int ret = 0;
 761     const ASN1_PRIMITIVE_FUNCS *pf;
 762     ASN1_INTEGER **tint;
 763     pf = it->funcs;
 764
 765     if (pf && pf->prim_c2i)
 766         return pf->prim_c2i(pval, cont, len, utype, free_cont, it);
 767     /* If ANY type clear type and set pointer to internal value */
 768     if (it->utype == V_ASN1_ANY) {
 769         if (!*pval) {
 770             typ = ASN1_TYPE_new();
 771             if (typ == NULL)
 772                 goto err;
 773             *pval = (ASN1_VALUE *)typ;
 774         } else
 775             typ = (ASN1_TYPE *)*pval;
 776
 777         if (utype != typ->type)
 778             ASN1_TYPE_set(typ, utype, NULL);
 779         opval = pval;
 780         pval = &typ->value.asn1_value;
 781     }
 782     switch (utype) {
 783     case V_ASN1_OBJECT:
 784         if (!c2i_ASN1_OBJECT((ASN1_OBJECT **)pval, &cont, len))
 785             goto err;
 786         break;
 787
 788     case V_ASN1_NULL:
 789         if (len) {
 790             ASN1err(ASN1_F_ASN1_EX_C2I, ASN1_R_NULL_IS_WRONG_LENGTH);
 791             goto err;
 792         }
 793         *pval = (ASN1_VALUE *)1;
 794         break;
 795
 796     case V_ASN1_BOOLEAN:
 797         if (len != 1) {
 798             ASN1err(ASN1_F_ASN1_EX_C2I, ASN1_R_BOOLEAN_IS_WRONG_LENGTH);
 799             goto err;
 800         } else {
 801             ASN1_BOOLEAN *tbool;
 802             tbool = (ASN1_BOOLEAN *)pval;
 803             *tbool = *cont;
 804         }
 805         break;
 806
 807     case V_ASN1_BIT_STRING:
 808         if (!c2i_ASN1_BIT_STRING((ASN1_BIT_STRING **)pval, &cont, len))
 809             goto err;
 810         break;
 811
 812     case V_ASN1_INTEGER:
 813     case V_ASN1_ENUMERATED:
 814         tint = (ASN1_INTEGER **)pval;
 815         if (!c2i_ASN1_INTEGER(tint, &cont, len))
 816             goto err;
 817         /* Fixup type to match the expected form */
 818         (*tint)->type = utype | ((*tint)->type & V_ASN1_NEG);
 819         break;
 820
 821     case V_ASN1_OCTET_STRING:
 822     case V_ASN1_NUMERICSTRING:
 823     case V_ASN1_PRINTABLESTRING:
 824     case V_ASN1_T61STRING:
 825     case V_ASN1_VIDEOTEXSTRING:
 826     case V_ASN1_IA5STRING:
 827     case V_ASN1_UTCTIME:
 828     case V_ASN1_GENERALIZEDTIME:
 829     case V_ASN1_GRAPHICSTRING:
 830     case V_ASN1_VISIBLESTRING:
 831     case V_ASN1_GENERALSTRING:
 832     case V_ASN1_UNIVERSALSTRING:
 833     case V_ASN1_BMPSTRING:
 834     case V_ASN1_UTF8STRING:
 835     case V_ASN1_OTHER:
 836     case V_ASN1_SET:
 837     case V_ASN1_SEQUENCE:
 838     default:
 839         if (utype == V_ASN1_BMPSTRING && (len & 1)) {
 840             ASN1err(ASN1_F_ASN1_EX_C2I, ASN1_R_BMPSTRING_IS_WRONG_LENGTH);
 841             goto err;
 842         }
 843         if (utype == V_ASN1_UNIVERSALSTRING && (len & 3)) {
 844             ASN1err(ASN1_F_ASN1_EX_C2I,
 845                     ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH);
 846             goto err;
 847         }
 848         /* All based on ASN1_STRING and handled the same */
 849         if (!*pval) {
 850             stmp = ASN1_STRING_type_new(utype);
 851             if (stmp == NULL) {
 852                 ASN1err(ASN1_F_ASN1_EX_C2I, ERR_R_MALLOC_FAILURE);
 853                 goto err;
 854             }
 855             *pval = (ASN1_VALUE *)stmp;
 856         } else {
 857             stmp = (ASN1_STRING *)*pval;
 858             stmp->type = utype;
 859         }
 860         /* If we've already allocated a buffer use it */
 861         if (*free_cont) {
 862             OPENSSL_free(stmp->data);
 863             stmp->data = (unsigned char *)cont; /* UGLY CAST! RL */
 864             stmp->length = len;
 865             *free_cont = 0;
 866         } else {
 867             if (!ASN1_STRING_set(stmp, cont, len)) {
 868                 ASN1err(ASN1_F_ASN1_EX_C2I, ERR_R_MALLOC_FAILURE);
 869                 ASN1_STRING_free(stmp);
 870                 *pval = NULL;
 871                 goto err;
 872             }
 873         }
 874         break;
 875     }
 876     /* If ASN1_ANY and NULL type fix up value */
 877     if (typ && (utype == V_ASN1_NULL))
 878         typ->value.ptr = NULL;
 879
 880     ret = 1;
 881  err:
 882     if (!ret) {
 883         ASN1_TYPE_free(typ);
 884         if (opval)
 885             *opval = NULL;
 886     }
 887     return ret;
 888 }
 889
 890 /*
 891  * This function finds the end of an ASN1 structure when passed its maximum
 892  * length, whether it is indefinite length and a pointer to the content. This
 893  * is more efficient than calling asn1_collect because it does not recurse on
 894  * each indefinite length header.
 895  */
 896
 897 static int asn1_find_end(const unsigned char **in, long len, char inf)
 898 {
 899     uint32_t expected_eoc;
 900     long plen;
 901     const unsigned char *p = *in, *q;
 902     /* If not indefinite length constructed just add length */
 903     if (inf == 0) {
 904         *in += len;
 905         return 1;
 906     }
 907     expected_eoc = 1;
 908     /*
 909      * Indefinite length constructed form. Find the end when enough EOCs are
 910      * found. If more indefinite length constructed headers are encountered
 911      * increment the expected eoc count otherwise just skip to the end of the
 912      * data.
 913      */
 914     while (len > 0) {
 915         if (asn1_check_eoc(&p, len)) {
 916             expected_eoc--;
 917             if (expected_eoc == 0)
 918                 break;
 919             len -= 2;
 920             continue;
 921         }
 922         q = p;
 923         /* Just read in a header: only care about the length */
 924         if (!asn1_check_tlen(&plen, NULL, NULL, &inf, NULL, &p, len,
 925                              -1, 0, 0, NULL)) {
 926             ASN1err(ASN1_F_ASN1_FIND_END, ERR_R_NESTED_ASN1_ERROR);
 927             return 0;
 928         }
 929         if (inf) {
 930             if (expected_eoc == UINT32_MAX) {
 931                 ASN1err(ASN1_F_ASN1_FIND_END, ERR_R_NESTED_ASN1_ERROR);
 932                 return 0;
 933             }
 934             expected_eoc++;
 935         } else {
 936             p += plen;
 937         }
 938         len -= p - q;
 939     }
 940     if (expected_eoc) {
 941         ASN1err(ASN1_F_ASN1_FIND_END, ASN1_R_MISSING_EOC);
 942         return 0;
 943     }
 944     *in = p;
 945     return 1;
 946 }
 947
 948 /*
 949  * This function collects the asn1 data from a constructed string type into
 950  * a buffer. The values of 'in' and 'len' should refer to the contents of the
 951  * constructed type and 'inf' should be set if it is indefinite length.
 952  */
 953
 954 #ifndef ASN1_MAX_STRING_NEST
 955 /*
 956  * This determines how many levels of recursion are permitted in ASN1 string
 957  * types. If it is not limited stack overflows can occur. If set to zero no
 958  * recursion is allowed at all. Although zero should be adequate examples
 959  * exist that require a value of 1. So 5 should be more than enough.
 960  */
 961 # define ASN1_MAX_STRING_NEST 5
 962 #endif
 963
 964 static int asn1_collect(BUF_MEM *buf, const unsigned char **in, long len,
 965                         char inf, int tag, int aclass, int depth)
 966 {
 967     const unsigned char *p, *q;
 968     long plen;
 969     char cst, ininf;
 970     p = *in;
 971     inf &= 1;
 972     /*
 973      * If no buffer and not indefinite length constructed just pass over the
 974      * encoded data
 975      */
 976     if (!buf && !inf) {
 977         *in += len;
 978         return 1;
 979     }
 980     while (len > 0) {
 981         q = p;
 982         /* Check for EOC */
 983         if (asn1_check_eoc(&p, len)) {
 984             /*
 985              * EOC is illegal outside indefinite length constructed form
 986              */
 987             if (!inf) {
 988                 ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_UNEXPECTED_EOC);
 989                 return 0;
 990             }
 991             inf = 0;
 992             break;
 993         }
 994
 995         if (!asn1_check_tlen(&plen, NULL, NULL, &ininf, &cst, &p,
 996                              len, tag, aclass, 0, NULL)) {
 997             ASN1err(ASN1_F_ASN1_COLLECT, ERR_R_NESTED_ASN1_ERROR);
 998             return 0;
 999         }
1000
1001         /* If indefinite length constructed update max length */
1002         if (cst) {
1003             if (depth >= ASN1_MAX_STRING_NEST) {
1004                 ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_NESTED_ASN1_STRING);
1005                 return 0;
1006             }
1007             if (!asn1_collect(buf, &p, plen, ininf, tag, aclass, depth + 1))
1008                 return 0;
1009         } else if (plen && !collect_data(buf, &p, plen))
1010             return 0;
1011         len -= p - q;
1012     }
1013     if (inf) {
1014         ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_MISSING_EOC);
1015         return 0;
1016     }
1017     *in = p;
1018     return 1;
1019 }
1020
1021 static int collect_data(BUF_MEM *buf, const unsigned char **p, long plen)
1022 {
1023     int len;
1024     if (buf) {
1025         len = buf->length;
1026         if (!BUF_MEM_grow_clean(buf, len + plen)) {
1027             ASN1err(ASN1_F_COLLECT_DATA, ERR_R_MALLOC_FAILURE);
1028             return 0;
1029         }
1030         memcpy(buf->data + len, *p, plen);
1031     }
1032     *p += plen;
1033     return 1;
1034 }
1035
1036 /* Check for ASN1 EOC and swallow it if found */
1037
1038 static int asn1_check_eoc(const unsigned char **in, long len)
1039 {
1040     const unsigned char *p;
1041     if (len < 2)
1042         return 0;
1043     p = *in;
1044     if (!p[0] && !p[1]) {
1045         *in += 2;
1046         return 1;
1047     }
1048     return 0;
1049 }
1050
1051 /*
1052  * Check an ASN1 tag and length: a bit like ASN1_get_object but it sets the
1053  * length for indefinite length constructed form, we don't know the exact
1054  * length but we can set an upper bound to the amount of data available minus
1055  * the header length just read.
1056  */
1057
1058 static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass,
1059                            char *inf, char *cst,
1060                            const unsigned char **in, long len,
1061                            int exptag, int expclass, char opt, ASN1_TLC *ctx)
1062 {
1063     int i;
1064     int ptag, pclass;
1065     long plen;
1066     const unsigned char *p, *q;
1067     p = *in;
1068     q = p;
1069
1070     if (ctx && ctx->valid) {
1071         i = ctx->ret;
1072         plen = ctx->plen;
1073         pclass = ctx->pclass;
1074         ptag = ctx->ptag;
1075         p += ctx->hdrlen;
1076     } else {
1077         i = ASN1_get_object(&p, &plen, &ptag, &pclass, len);
1078         if (ctx) {
1079             ctx->ret = i;
1080             ctx->plen = plen;
1081             ctx->pclass = pclass;
1082             ctx->ptag = ptag;
1083             ctx->hdrlen = p - q;
1084             ctx->valid = 1;
1085             /*
1086              * If definite length, and no error, length + header can't exceed
1087              * total amount of data available.
1088              */
1089             if (!(i & 0x81) && ((plen + ctx->hdrlen) > len)) {
1090                 ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_TOO_LONG);
1091                 asn1_tlc_clear(ctx);
1092                 return 0;
1093             }
1094         }
1095     }
1096
1097     if (i & 0x80) {
1098         ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_BAD_OBJECT_HEADER);
1099         asn1_tlc_clear(ctx);
1100         return 0;
1101     }
1102     if (exptag >= 0) {
1103         if ((exptag != ptag) || (expclass != pclass)) {
1104             /*
1105              * If type is OPTIONAL, not an error: indicate missing type.
1106              */
1107             if (opt)
1108                 return -1;
1109             asn1_tlc_clear(ctx);
1110             ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_WRONG_TAG);
1111             return 0;
1112         }
1113         /*
1114          * We have a tag and class match: assume we are going to do something
1115          * with it
1116          */
1117         asn1_tlc_clear(ctx);
1118     }
1119
1120     if (i & 1)
1121         plen = len - (p - q);
1122
1123     if (inf)
1124         *inf = i & 1;
1125
1126     if (cst)
1127         *cst = i & V_ASN1_CONSTRUCTED;
1128
1129     if (olen)
1130         *olen = plen;
1131
1132     if (oclass)
1133         *oclass = pclass;
1134
1135     if (otag)
1136         *otag = ptag;
1137
1138     *in = p;
1139     return 1;
1140 }