Constify ASN1_PCTX_*
[openssl.git] / 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, 0);
304                 if (seqtt == NULL)
305                     continue;
306                 pseqval = asn1_get_field_ptr(pval, seqtt);
307                 asn1_template_free(pseqval, seqtt);
308             }
309         }
310
311         /* Get each field entry */
312         for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
313             const ASN1_TEMPLATE *seqtt;
314             ASN1_VALUE **pseqval;
315             seqtt = asn1_do_adb(pval, tt, 1);
316             if (seqtt == NULL)
317                 goto err;
318             pseqval = asn1_get_field_ptr(pval, seqtt);
319             /* Have we ran out of data? */
320             if (!len)
321                 break;
322             q = p;
323             if (asn1_check_eoc(&p, len)) {
324                 if (!seq_eoc) {
325                     ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_UNEXPECTED_EOC);
326                     goto err;
327                 }
328                 len -= p - q;
329                 seq_eoc = 0;
330                 q = p;
331                 break;
332             }
333             /*
334              * This determines the OPTIONAL flag value. The field cannot be
335              * omitted if it is the last of a SEQUENCE and there is still
336              * data to be read. This isn't strictly necessary but it
337              * increases efficiency in some cases.
338              */
339             if (i == (it->tcount - 1))
340                 isopt = 0;
341             else
342                 isopt = (char)(seqtt->flags & ASN1_TFLG_OPTIONAL);
343             /*
344              * attempt to read in field, allowing each to be OPTIONAL
345              */
346
347             ret = asn1_template_ex_d2i(pseqval, &p, len, seqtt, isopt, ctx);
348             if (!ret) {
349                 errtt = seqtt;
350                 goto err;
351             } else if (ret == -1) {
352                 /*
353                  * OPTIONAL component absent. Free and zero the field.
354                  */
355                 asn1_template_free(pseqval, seqtt);
356                 continue;
357             }
358             /* Update length */
359             len -= p - q;
360         }
361
362         /* Check for EOC if expecting one */
363         if (seq_eoc && !asn1_check_eoc(&p, len)) {
364             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_MISSING_EOC);
365             goto err;
366         }
367         /* Check all data read */
368         if (!seq_nolen && len) {
369             ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_SEQUENCE_LENGTH_MISMATCH);
370             goto err;
371         }
372
373         /*
374          * If we get here we've got no more data in the SEQUENCE, however we
375          * may not have read all fields so check all remaining are OPTIONAL
376          * and clear any that are.
377          */
378         for (; i < it->tcount; tt++, i++) {
379             const ASN1_TEMPLATE *seqtt;
380             seqtt = asn1_do_adb(pval, tt, 1);
381             if (seqtt == NULL)
382                 goto err;
383             if (seqtt->flags & ASN1_TFLG_OPTIONAL) {
384                 ASN1_VALUE **pseqval;
385                 pseqval = asn1_get_field_ptr(pval, seqtt);
386                 asn1_template_free(pseqval, seqtt);
387             } else {
388                 errtt = seqtt;
389                 ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_FIELD_MISSING);
390                 goto err;
391             }
392         }
393         /* Save encoding */
394         if (!asn1_enc_save(pval, *in, p - *in, it))
395             goto auxerr;
396         if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL))
397             goto auxerr;
398         *in = p;
399         return 1;
400
401     default:
402         return 0;
403     }
404  auxerr:
405     ASN1err(ASN1_F_ASN1_ITEM_EMBED_D2I, ASN1_R_AUX_ERROR);
406  err:
407     if (errtt)
408         ERR_add_error_data(4, "Field=", errtt->field_name,
409                            ", Type=", it->sname);
410     else
411         ERR_add_error_data(2, "Type=", it->sname);
412     return 0;
413 }
414
415 /*
416  * Templates are handled with two separate functions. One handles any
417  * EXPLICIT tag and the other handles the rest.
418  */
419
420 static int asn1_template_ex_d2i(ASN1_VALUE **val,
421                                 const unsigned char **in, long inlen,
422                                 const ASN1_TEMPLATE *tt, char opt,
423                                 ASN1_TLC *ctx)
424 {
425     int flags, aclass;
426     int ret;
427     long len;
428     const unsigned char *p, *q;
429     char exp_eoc;
430     if (!val)
431         return 0;
432     flags = tt->flags;
433     aclass = flags & ASN1_TFLG_TAG_CLASS;
434
435     p = *in;
436
437     /* Check if EXPLICIT tag expected */
438     if (flags & ASN1_TFLG_EXPTAG) {
439         char cst;
440         /*
441          * Need to work out amount of data available to the inner content and
442          * where it starts: so read in EXPLICIT header to get the info.
443          */
444         ret = asn1_check_tlen(&len, NULL, NULL, &exp_eoc, &cst,
445                               &p, inlen, tt->tag, aclass, opt, ctx);
446         q = p;
447         if (!ret) {
448             ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_NESTED_ASN1_ERROR);
449             return 0;
450         } else if (ret == -1)
451             return -1;
452         if (!cst) {
453             ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I,
454                     ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED);
455             return 0;
456         }
457         /* We've found the field so it can't be OPTIONAL now */
458         ret = asn1_template_noexp_d2i(val, &p, len, tt, 0, ctx);
459         if (!ret) {
460             ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_NESTED_ASN1_ERROR);
461             return 0;
462         }
463         /* We read the field in OK so update length */
464         len -= p - q;
465         if (exp_eoc) {
466             /* If NDEF we must have an EOC here */
467             if (!asn1_check_eoc(&p, len)) {
468                 ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ASN1_R_MISSING_EOC);
469                 goto err;
470             }
471         } else {
472             /*
473              * Otherwise we must hit the EXPLICIT tag end or its an error
474              */
475             if (len) {
476                 ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I,
477                         ASN1_R_EXPLICIT_LENGTH_MISMATCH);
478                 goto err;
479             }
480         }
481     } else
482         return asn1_template_noexp_d2i(val, in, inlen, tt, opt, ctx);
483
484     *in = p;
485     return 1;
486
487  err:
488     return 0;
489 }
490
491 static int asn1_template_noexp_d2i(ASN1_VALUE **val,
492                                    const unsigned char **in, long len,
493                                    const ASN1_TEMPLATE *tt, char opt,
494                                    ASN1_TLC *ctx)
495 {
496     int flags, aclass;
497     int ret;
498     ASN1_VALUE *tval;
499     const unsigned char *p, *q;
500     if (!val)
501         return 0;
502     flags = tt->flags;
503     aclass = flags & ASN1_TFLG_TAG_CLASS;
504
505     p = *in;
506     q = p;
507
508     /*
509      * If field is embedded then val needs fixing so it is a pointer to
510      * a pointer to a field.
511      */
512     if (tt->flags & ASN1_TFLG_EMBED) {
513         tval = (ASN1_VALUE *)val;
514         val = &tval;
515     }
516
517     if (flags & ASN1_TFLG_SK_MASK) {
518         /* SET OF, SEQUENCE OF */
519         int sktag, skaclass;
520         char sk_eoc;
521         /* First work out expected inner tag value */
522         if (flags & ASN1_TFLG_IMPTAG) {
523             sktag = tt->tag;
524             skaclass = aclass;
525         } else {
526             skaclass = V_ASN1_UNIVERSAL;
527             if (flags & ASN1_TFLG_SET_OF)
528                 sktag = V_ASN1_SET;
529             else
530                 sktag = V_ASN1_SEQUENCE;
531         }
532         /* Get the tag */
533         ret = asn1_check_tlen(&len, NULL, NULL, &sk_eoc, NULL,
534                               &p, len, sktag, skaclass, opt, ctx);
535         if (!ret) {
536             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
537             return 0;
538         } else if (ret == -1)
539             return -1;
540         if (!*val)
541             *val = (ASN1_VALUE *)OPENSSL_sk_new_null();
542         else {
543             /*
544              * We've got a valid STACK: free up any items present
545              */
546             STACK_OF(ASN1_VALUE) *sktmp = (STACK_OF(ASN1_VALUE) *)*val;
547             ASN1_VALUE *vtmp;
548             while (sk_ASN1_VALUE_num(sktmp) > 0) {
549                 vtmp = sk_ASN1_VALUE_pop(sktmp);
550                 ASN1_item_ex_free(&vtmp, ASN1_ITEM_ptr(tt->item));
551             }
552         }
553
554         if (!*val) {
555             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_MALLOC_FAILURE);
556             goto err;
557         }
558
559         /* Read as many items as we can */
560         while (len > 0) {
561             ASN1_VALUE *skfield;
562             q = p;
563             /* See if EOC found */
564             if (asn1_check_eoc(&p, len)) {
565                 if (!sk_eoc) {
566                     ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I,
567                             ASN1_R_UNEXPECTED_EOC);
568                     goto err;
569                 }
570                 len -= p - q;
571                 sk_eoc = 0;
572                 break;
573             }
574             skfield = NULL;
575             if (!asn1_item_embed_d2i(&skfield, &p, len,
576                                      ASN1_ITEM_ptr(tt->item), -1, 0, 0, ctx)) {
577                 ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I,
578                         ERR_R_NESTED_ASN1_ERROR);
579                 /* |skfield| may be partially allocated despite failure. */
580                 ASN1_item_free(skfield, ASN1_ITEM_ptr(tt->item));
581                 goto err;
582             }
583             len -= p - q;
584             if (!sk_ASN1_VALUE_push((STACK_OF(ASN1_VALUE) *)*val, skfield)) {
585                 ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_MALLOC_FAILURE);
586                 ASN1_item_free(skfield, ASN1_ITEM_ptr(tt->item));
587                 goto err;
588             }
589         }
590         if (sk_eoc) {
591             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ASN1_R_MISSING_EOC);
592             goto err;
593         }
594     } else if (flags & ASN1_TFLG_IMPTAG) {
595         /* IMPLICIT tagging */
596         ret = asn1_item_embed_d2i(val, &p, len,
597                                   ASN1_ITEM_ptr(tt->item), tt->tag, aclass, opt,
598                                   ctx);
599         if (!ret) {
600             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
601             goto err;
602         } else if (ret == -1)
603             return -1;
604     } else {
605         /* Nothing special */
606         ret = asn1_item_embed_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item),
607                                   -1, 0, opt, ctx);
608         if (!ret) {
609             ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
610             goto err;
611         } else if (ret == -1)
612             return -1;
613     }
614
615     *in = p;
616     return 1;
617
618  err:
619     return 0;
620 }
621
622 static int asn1_d2i_ex_primitive(ASN1_VALUE **pval,
623                                  const unsigned char **in, long inlen,
624                                  const ASN1_ITEM *it,
625                                  int tag, int aclass, char opt, ASN1_TLC *ctx)
626 {
627     int ret = 0, utype;
628     long plen;
629     char cst, inf, free_cont = 0;
630     const unsigned char *p;
631     BUF_MEM buf = { 0, NULL, 0, 0 };
632     const unsigned char *cont = NULL;
633     long len;
634     if (!pval) {
635         ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_NULL);
636         return 0;               /* Should never happen */
637     }
638
639     if (it->itype == ASN1_ITYPE_MSTRING) {
640         utype = tag;
641         tag = -1;
642     } else
643         utype = it->utype;
644
645     if (utype == V_ASN1_ANY) {
646         /* If type is ANY need to figure out type from tag */
647         unsigned char oclass;
648         if (tag >= 0) {
649             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_TAGGED_ANY);
650             return 0;
651         }
652         if (opt) {
653             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE,
654                     ASN1_R_ILLEGAL_OPTIONAL_ANY);
655             return 0;
656         }
657         p = *in;
658         ret = asn1_check_tlen(NULL, &utype, &oclass, NULL, NULL,
659                               &p, inlen, -1, 0, 0, ctx);
660         if (!ret) {
661             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_NESTED_ASN1_ERROR);
662             return 0;
663         }
664         if (oclass != V_ASN1_UNIVERSAL)
665             utype = V_ASN1_OTHER;
666     }
667     if (tag == -1) {
668         tag = utype;
669         aclass = V_ASN1_UNIVERSAL;
670     }
671     p = *in;
672     /* Check header */
673     ret = asn1_check_tlen(&plen, NULL, NULL, &inf, &cst,
674                           &p, inlen, tag, aclass, opt, ctx);
675     if (!ret) {
676         ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_NESTED_ASN1_ERROR);
677         return 0;
678     } else if (ret == -1)
679         return -1;
680     ret = 0;
681     /* SEQUENCE, SET and "OTHER" are left in encoded form */
682     if ((utype == V_ASN1_SEQUENCE)
683         || (utype == V_ASN1_SET) || (utype == V_ASN1_OTHER)) {
684         /*
685          * Clear context cache for type OTHER because the auto clear when we
686          * have a exact match won't work
687          */
688         if (utype == V_ASN1_OTHER) {
689             asn1_tlc_clear(ctx);
690         }
691         /* SEQUENCE and SET must be constructed */
692         else if (!cst) {
693             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE,
694                     ASN1_R_TYPE_NOT_CONSTRUCTED);
695             return 0;
696         }
697
698         cont = *in;
699         /* If indefinite length constructed find the real end */
700         if (inf) {
701             if (!asn1_find_end(&p, plen, inf))
702                 goto err;
703             len = p - cont;
704         } else {
705             len = p - cont + plen;
706             p += plen;
707         }
708     } else if (cst) {
709         if (utype == V_ASN1_NULL || utype == V_ASN1_BOOLEAN
710             || utype == V_ASN1_OBJECT || utype == V_ASN1_INTEGER
711             || utype == V_ASN1_ENUMERATED) {
712             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_TYPE_NOT_PRIMITIVE);
713             return 0;
714         }
715
716         /* Free any returned 'buf' content */
717         free_cont = 1;
718         /*
719          * Should really check the internal tags are correct but some things
720          * may get this wrong. The relevant specs say that constructed string
721          * types should be OCTET STRINGs internally irrespective of the type.
722          * So instead just check for UNIVERSAL class and ignore the tag.
723          */
724         if (!asn1_collect(&buf, &p, plen, inf, -1, V_ASN1_UNIVERSAL, 0)) {
725             goto err;
726         }
727         len = buf.length;
728         /* Append a final null to string */
729         if (!BUF_MEM_grow_clean(&buf, len + 1)) {
730             ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_MALLOC_FAILURE);
731             goto err;
732         }
733         buf.data[len] = 0;
734         cont = (const unsigned char *)buf.data;
735     } else {
736         cont = p;
737         len = plen;
738         p += plen;
739     }
740
741     /* We now have content length and type: translate into a structure */
742     /* asn1_ex_c2i may reuse allocated buffer, and so sets free_cont to 0 */
743     if (!asn1_ex_c2i(pval, cont, len, utype, &free_cont, it))
744         goto err;
745
746     *in = p;
747     ret = 1;
748  err:
749     if (free_cont)
750         OPENSSL_free(buf.data);
751     return ret;
752 }
753
754 /* Translate ASN1 content octets into a structure */
755
756 static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
757                        int utype, char *free_cont, const ASN1_ITEM *it)
758 {
759     ASN1_VALUE **opval = NULL;
760     ASN1_STRING *stmp;
761     ASN1_TYPE *typ = NULL;
762     int ret = 0;
763     const ASN1_PRIMITIVE_FUNCS *pf;
764     ASN1_INTEGER **tint;
765     pf = it->funcs;
766
767     if (pf && pf->prim_c2i)
768         return pf->prim_c2i(pval, cont, len, utype, free_cont, it);
769     /* If ANY type clear type and set pointer to internal value */
770     if (it->utype == V_ASN1_ANY) {
771         if (!*pval) {
772             typ = ASN1_TYPE_new();
773             if (typ == NULL)
774                 goto err;
775             *pval = (ASN1_VALUE *)typ;
776         } else
777             typ = (ASN1_TYPE *)*pval;
778
779         if (utype != typ->type)
780             ASN1_TYPE_set(typ, utype, NULL);
781         opval = pval;
782         pval = &typ->value.asn1_value;
783     }
784     switch (utype) {
785     case V_ASN1_OBJECT:
786         if (!c2i_ASN1_OBJECT((ASN1_OBJECT **)pval, &cont, len))
787             goto err;
788         break;
789
790     case V_ASN1_NULL:
791         if (len) {
792             ASN1err(ASN1_F_ASN1_EX_C2I, ASN1_R_NULL_IS_WRONG_LENGTH);
793             goto err;
794         }
795         *pval = (ASN1_VALUE *)1;
796         break;
797
798     case V_ASN1_BOOLEAN:
799         if (len != 1) {
800             ASN1err(ASN1_F_ASN1_EX_C2I, ASN1_R_BOOLEAN_IS_WRONG_LENGTH);
801             goto err;
802         } else {
803             ASN1_BOOLEAN *tbool;
804             tbool = (ASN1_BOOLEAN *)pval;
805             *tbool = *cont;
806         }
807         break;
808
809     case V_ASN1_BIT_STRING:
810         if (!c2i_ASN1_BIT_STRING((ASN1_BIT_STRING **)pval, &cont, len))
811             goto err;
812         break;
813
814     case V_ASN1_INTEGER:
815     case V_ASN1_ENUMERATED:
816         tint = (ASN1_INTEGER **)pval;
817         if (!c2i_ASN1_INTEGER(tint, &cont, len))
818             goto err;
819         /* Fixup type to match the expected form */
820         (*tint)->type = utype | ((*tint)->type & V_ASN1_NEG);
821         break;
822
823     case V_ASN1_OCTET_STRING:
824     case V_ASN1_NUMERICSTRING:
825     case V_ASN1_PRINTABLESTRING:
826     case V_ASN1_T61STRING:
827     case V_ASN1_VIDEOTEXSTRING:
828     case V_ASN1_IA5STRING:
829     case V_ASN1_UTCTIME:
830     case V_ASN1_GENERALIZEDTIME:
831     case V_ASN1_GRAPHICSTRING:
832     case V_ASN1_VISIBLESTRING:
833     case V_ASN1_GENERALSTRING:
834     case V_ASN1_UNIVERSALSTRING:
835     case V_ASN1_BMPSTRING:
836     case V_ASN1_UTF8STRING:
837     case V_ASN1_OTHER:
838     case V_ASN1_SET:
839     case V_ASN1_SEQUENCE:
840     default:
841         if (utype == V_ASN1_BMPSTRING && (len & 1)) {
842             ASN1err(ASN1_F_ASN1_EX_C2I, ASN1_R_BMPSTRING_IS_WRONG_LENGTH);
843             goto err;
844         }
845         if (utype == V_ASN1_UNIVERSALSTRING && (len & 3)) {
846             ASN1err(ASN1_F_ASN1_EX_C2I,
847                     ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH);
848             goto err;
849         }
850         /* All based on ASN1_STRING and handled the same */
851         if (!*pval) {
852             stmp = ASN1_STRING_type_new(utype);
853             if (stmp == NULL) {
854                 ASN1err(ASN1_F_ASN1_EX_C2I, ERR_R_MALLOC_FAILURE);
855                 goto err;
856             }
857             *pval = (ASN1_VALUE *)stmp;
858         } else {
859             stmp = (ASN1_STRING *)*pval;
860             stmp->type = utype;
861         }
862         /* If we've already allocated a buffer use it */
863         if (*free_cont) {
864             OPENSSL_free(stmp->data);
865             stmp->data = (unsigned char *)cont; /* UGLY CAST! RL */
866             stmp->length = len;
867             *free_cont = 0;
868         } else {
869             if (!ASN1_STRING_set(stmp, cont, len)) {
870                 ASN1err(ASN1_F_ASN1_EX_C2I, ERR_R_MALLOC_FAILURE);
871                 ASN1_STRING_free(stmp);
872                 *pval = NULL;
873                 goto err;
874             }
875         }
876         break;
877     }
878     /* If ASN1_ANY and NULL type fix up value */
879     if (typ && (utype == V_ASN1_NULL))
880         typ->value.ptr = NULL;
881
882     ret = 1;
883  err:
884     if (!ret) {
885         ASN1_TYPE_free(typ);
886         if (opval)
887             *opval = NULL;
888     }
889     return ret;
890 }
891
892 /*
893  * This function finds the end of an ASN1 structure when passed its maximum
894  * length, whether it is indefinite length and a pointer to the content. This
895  * is more efficient than calling asn1_collect because it does not recurse on
896  * each indefinite length header.
897  */
898
899 static int asn1_find_end(const unsigned char **in, long len, char inf)
900 {
901     uint32_t expected_eoc;
902     long plen;
903     const unsigned char *p = *in, *q;
904     /* If not indefinite length constructed just add length */
905     if (inf == 0) {
906         *in += len;
907         return 1;
908     }
909     expected_eoc = 1;
910     /*
911      * Indefinite length constructed form. Find the end when enough EOCs are
912      * found. If more indefinite length constructed headers are encountered
913      * increment the expected eoc count otherwise just skip to the end of the
914      * data.
915      */
916     while (len > 0) {
917         if (asn1_check_eoc(&p, len)) {
918             expected_eoc--;
919             if (expected_eoc == 0)
920                 break;
921             len -= 2;
922             continue;
923         }
924         q = p;
925         /* Just read in a header: only care about the length */
926         if (!asn1_check_tlen(&plen, NULL, NULL, &inf, NULL, &p, len,
927                              -1, 0, 0, NULL)) {
928             ASN1err(ASN1_F_ASN1_FIND_END, ERR_R_NESTED_ASN1_ERROR);
929             return 0;
930         }
931         if (inf) {
932             if (expected_eoc == UINT32_MAX) {
933                 ASN1err(ASN1_F_ASN1_FIND_END, ERR_R_NESTED_ASN1_ERROR);
934                 return 0;
935             }
936             expected_eoc++;
937         } else {
938             p += plen;
939         }
940         len -= p - q;
941     }
942     if (expected_eoc) {
943         ASN1err(ASN1_F_ASN1_FIND_END, ASN1_R_MISSING_EOC);
944         return 0;
945     }
946     *in = p;
947     return 1;
948 }
949
950 /*
951  * This function collects the asn1 data from a constructed string type into
952  * a buffer. The values of 'in' and 'len' should refer to the contents of the
953  * constructed type and 'inf' should be set if it is indefinite length.
954  */
955
956 #ifndef ASN1_MAX_STRING_NEST
957 /*
958  * This determines how many levels of recursion are permitted in ASN1 string
959  * types. If it is not limited stack overflows can occur. If set to zero no
960  * recursion is allowed at all. Although zero should be adequate examples
961  * exist that require a value of 1. So 5 should be more than enough.
962  */
963 # define ASN1_MAX_STRING_NEST 5
964 #endif
965
966 static int asn1_collect(BUF_MEM *buf, const unsigned char **in, long len,
967                         char inf, int tag, int aclass, int depth)
968 {
969     const unsigned char *p, *q;
970     long plen;
971     char cst, ininf;
972     p = *in;
973     inf &= 1;
974     /*
975      * If no buffer and not indefinite length constructed just pass over the
976      * encoded data
977      */
978     if (!buf && !inf) {
979         *in += len;
980         return 1;
981     }
982     while (len > 0) {
983         q = p;
984         /* Check for EOC */
985         if (asn1_check_eoc(&p, len)) {
986             /*
987              * EOC is illegal outside indefinite length constructed form
988              */
989             if (!inf) {
990                 ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_UNEXPECTED_EOC);
991                 return 0;
992             }
993             inf = 0;
994             break;
995         }
996
997         if (!asn1_check_tlen(&plen, NULL, NULL, &ininf, &cst, &p,
998                              len, tag, aclass, 0, NULL)) {
999             ASN1err(ASN1_F_ASN1_COLLECT, ERR_R_NESTED_ASN1_ERROR);
1000             return 0;
1001         }
1002
1003         /* If indefinite length constructed update max length */
1004         if (cst) {
1005             if (depth >= ASN1_MAX_STRING_NEST) {
1006                 ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_NESTED_ASN1_STRING);
1007                 return 0;
1008             }
1009             if (!asn1_collect(buf, &p, plen, ininf, tag, aclass, depth + 1))
1010                 return 0;
1011         } else if (plen && !collect_data(buf, &p, plen))
1012             return 0;
1013         len -= p - q;
1014     }
1015     if (inf) {
1016         ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_MISSING_EOC);
1017         return 0;
1018     }
1019     *in = p;
1020     return 1;
1021 }
1022
1023 static int collect_data(BUF_MEM *buf, const unsigned char **p, long plen)
1024 {
1025     int len;
1026     if (buf) {
1027         len = buf->length;
1028         if (!BUF_MEM_grow_clean(buf, len + plen)) {
1029             ASN1err(ASN1_F_COLLECT_DATA, ERR_R_MALLOC_FAILURE);
1030             return 0;
1031         }
1032         memcpy(buf->data + len, *p, plen);
1033     }
1034     *p += plen;
1035     return 1;
1036 }
1037
1038 /* Check for ASN1 EOC and swallow it if found */
1039
1040 static int asn1_check_eoc(const unsigned char **in, long len)
1041 {
1042     const unsigned char *p;
1043     if (len < 2)
1044         return 0;
1045     p = *in;
1046     if (!p[0] && !p[1]) {
1047         *in += 2;
1048         return 1;
1049     }
1050     return 0;
1051 }
1052
1053 /*
1054  * Check an ASN1 tag and length: a bit like ASN1_get_object but it sets the
1055  * length for indefinite length constructed form, we don't know the exact
1056  * length but we can set an upper bound to the amount of data available minus
1057  * the header length just read.
1058  */
1059
1060 static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass,
1061                            char *inf, char *cst,
1062                            const unsigned char **in, long len,
1063                            int exptag, int expclass, char opt, ASN1_TLC *ctx)
1064 {
1065     int i;
1066     int ptag, pclass;
1067     long plen;
1068     const unsigned char *p, *q;
1069     p = *in;
1070     q = p;
1071
1072     if (ctx && ctx->valid) {
1073         i = ctx->ret;
1074         plen = ctx->plen;
1075         pclass = ctx->pclass;
1076         ptag = ctx->ptag;
1077         p += ctx->hdrlen;
1078     } else {
1079         i = ASN1_get_object(&p, &plen, &ptag, &pclass, len);
1080         if (ctx) {
1081             ctx->ret = i;
1082             ctx->plen = plen;
1083             ctx->pclass = pclass;
1084             ctx->ptag = ptag;
1085             ctx->hdrlen = p - q;
1086             ctx->valid = 1;
1087             /*
1088              * If definite length, and no error, length + header can't exceed
1089              * total amount of data available.
1090              */
1091             if (!(i & 0x81) && ((plen + ctx->hdrlen) > len)) {
1092                 ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_TOO_LONG);
1093                 asn1_tlc_clear(ctx);
1094                 return 0;
1095             }
1096         }
1097     }
1098
1099     if (i & 0x80) {
1100         ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_BAD_OBJECT_HEADER);
1101         asn1_tlc_clear(ctx);
1102         return 0;
1103     }
1104     if (exptag >= 0) {
1105         if ((exptag != ptag) || (expclass != pclass)) {
1106             /*
1107              * If type is OPTIONAL, not an error: indicate missing type.
1108              */
1109             if (opt)
1110                 return -1;
1111             asn1_tlc_clear(ctx);
1112             ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_WRONG_TAG);
1113             return 0;
1114         }
1115         /*
1116          * We have a tag and class match: assume we are going to do something
1117          * with it
1118          */
1119         asn1_tlc_clear(ctx);
1120     }
1121
1122     if (i & 1)
1123         plen = len - (p - q);
1124
1125     if (inf)
1126         *inf = i & 1;
1127
1128     if (cst)
1129         *cst = i & V_ASN1_CONSTRUCTED;
1130
1131     if (olen)
1132         *olen = plen;
1133
1134     if (oclass)
1135         *oclass = pclass;
1136
1137     if (otag)
1138         *otag = ptag;
1139
1140     *in = p;
1141     return 1;
1142 }