]>
Commit | Line | Data |
---|---|---|
9d6b1ce6 DSH |
1 | /* tasn_dec.c */ |
2 | /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL | |
3 | * project 2000. | |
4 | */ | |
5 | /* ==================================================================== | |
6 | * Copyright (c) 2000 The OpenSSL Project. All rights reserved. | |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * | |
12 | * 1. Redistributions of source code must retain the above copyright | |
13 | * notice, this list of conditions and the following disclaimer. | |
14 | * | |
15 | * 2. Redistributions in binary form must reproduce the above copyright | |
16 | * notice, this list of conditions and the following disclaimer in | |
17 | * the documentation and/or other materials provided with the | |
18 | * distribution. | |
19 | * | |
20 | * 3. All advertising materials mentioning features or use of this | |
21 | * software must display the following acknowledgment: | |
22 | * "This product includes software developed by the OpenSSL Project | |
23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | |
24 | * | |
25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
26 | * endorse or promote products derived from this software without | |
27 | * prior written permission. For written permission, please contact | |
28 | * licensing@OpenSSL.org. | |
29 | * | |
30 | * 5. Products derived from this software may not be called "OpenSSL" | |
31 | * nor may "OpenSSL" appear in their names without prior written | |
32 | * permission of the OpenSSL Project. | |
33 | * | |
34 | * 6. Redistributions of any form whatsoever must retain the following | |
35 | * acknowledgment: | |
36 | * "This product includes software developed by the OpenSSL Project | |
37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | |
38 | * | |
39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | |
51 | * ==================================================================== | |
52 | * | |
53 | * This product includes cryptographic software written by Eric Young | |
54 | * (eay@cryptsoft.com). This product includes software written by Tim | |
55 | * Hudson (tjh@cryptsoft.com). | |
56 | * | |
57 | */ | |
58 | ||
59 | ||
60 | #include <stddef.h> | |
a9daa467 | 61 | #include <string.h> |
9d6b1ce6 DSH |
62 | #include <openssl/asn1.h> |
63 | #include <openssl/asn1t.h> | |
64 | #include <openssl/objects.h> | |
65 | #include <openssl/buffer.h> | |
66 | #include <openssl/err.h> | |
67 | ||
68 | static int asn1_check_eoc(unsigned char **in, long len); | |
69 | static int asn1_collect(BUF_MEM *buf, unsigned char **in, long len, char inf, int tag, int aclass); | |
70 | static int collect_data(BUF_MEM *buf, unsigned char **p, long plen); | |
71 | static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass, char *inf, char *cst, | |
72 | unsigned char **in, long len, int exptag, int expclass, char opt, ASN1_TLC *ctx); | |
73 | static int asn1_template_ex_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx); | |
74 | static int asn1_template_noexp_d2i(ASN1_VALUE **val, unsigned char **in, long len, const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx); | |
75 | static int asn1_d2i_ex_primitive(ASN1_VALUE **pval, unsigned char **in, long len, | |
76 | const ASN1_ITEM *it, int tag, int aclass, char opt, ASN1_TLC *ctx); | |
77 | ||
1241126a DSH |
78 | /* Table to convert tags to bit values, used for MSTRING type */ |
79 | static unsigned long tag2bit[32]={ | |
80 | 0, 0, 0, B_ASN1_BIT_STRING, /* tags 0 - 3 */ | |
81 | B_ASN1_OCTET_STRING, 0, 0, B_ASN1_UNKNOWN,/* tags 4- 7 */ | |
82 | B_ASN1_UNKNOWN, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN,/* tags 8-11 */ | |
83 | B_ASN1_UTF8STRING,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,/* tags 12-15 */ | |
84 | 0, 0, B_ASN1_NUMERICSTRING,B_ASN1_PRINTABLESTRING, /* tags 16-19 */ | |
85 | B_ASN1_T61STRING,B_ASN1_VIDEOTEXSTRING,B_ASN1_IA5STRING, /* tags 20-22 */ | |
86 | B_ASN1_UTCTIME, B_ASN1_GENERALIZEDTIME, /* tags 23-24 */ | |
87 | B_ASN1_GRAPHICSTRING,B_ASN1_ISO64STRING,B_ASN1_GENERALSTRING, /* tags 25-27 */ | |
88 | B_ASN1_UNIVERSALSTRING,B_ASN1_UNKNOWN,B_ASN1_BMPSTRING,B_ASN1_UNKNOWN, /* tags 28-31 */ | |
89 | }; | |
90 | ||
91 | unsigned long ASN1_tag2bit(int tag) | |
92 | { | |
93 | if((tag < 0) || (tag > 30)) return 0; | |
94 | return tag2bit[tag]; | |
95 | } | |
96 | ||
9d6b1ce6 DSH |
97 | /* Macro to initialize and invalidate the cache */ |
98 | ||
99 | #define asn1_tlc_clear(c) if(c) (c)->valid = 0 | |
100 | ||
101 | /* Decode an ASN1 item, this currently behaves just | |
102 | * like a standard 'd2i' function. 'in' points to | |
103 | * a buffer to read the data from, in future we will | |
104 | * have more advanced versions that can input data | |
105 | * a piece at a time and this will simply be a special | |
106 | * case. | |
107 | */ | |
108 | ||
109 | ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_ITEM *it) | |
110 | { | |
111 | ASN1_TLC c; | |
112 | ASN1_VALUE *ptmpval = NULL; | |
113 | if(!pval) pval = &ptmpval; | |
114 | asn1_tlc_clear(&c); | |
115 | if(ASN1_item_ex_d2i(pval, in, len, it, -1, 0, 0, &c) > 0) | |
116 | return *pval; | |
117 | return NULL; | |
118 | } | |
119 | ||
120 | int ASN1_template_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_TEMPLATE *tt) | |
121 | { | |
122 | ASN1_TLC c; | |
123 | asn1_tlc_clear(&c); | |
124 | return asn1_template_ex_d2i(pval, in, len, tt, 0, &c); | |
125 | } | |
126 | ||
127 | ||
128 | /* Decode an item, taking care of IMPLICIT tagging, if any. | |
129 | * If 'opt' set and tag mismatch return -1 to handle OPTIONAL | |
130 | */ | |
131 | ||
132 | int ASN1_item_ex_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_ITEM *it, | |
133 | int tag, int aclass, char opt, ASN1_TLC *ctx) | |
134 | { | |
135 | const ASN1_TEMPLATE *tt, *errtt = NULL; | |
136 | const ASN1_COMPAT_FUNCS *cf; | |
137 | const ASN1_EXTERN_FUNCS *ef; | |
138 | const ASN1_AUX *aux = it->funcs; | |
139 | ASN1_aux_cb *asn1_cb; | |
140 | unsigned char *p, *q, imphack = 0, oclass; | |
141 | char seq_eoc, seq_nolen, cst, isopt; | |
142 | long tmplen; | |
143 | int i; | |
144 | int otag; | |
145 | int ret = 0; | |
146 | ASN1_VALUE *pchval, **pchptr, *ptmpval; | |
147 | if(!pval) return 0; | |
148 | if(aux && aux->asn1_cb) asn1_cb = aux->asn1_cb; | |
149 | else asn1_cb = 0; | |
150 | ||
151 | switch(it->itype) { | |
152 | ||
153 | case ASN1_ITYPE_PRIMITIVE: | |
b31cc2d9 DSH |
154 | if(it->templates) { |
155 | /* tagging or OPTIONAL is currently illegal on an item template | |
156 | * because the flags can't get passed down. In practice this isn't | |
157 | * a problem: we include the relevant flags from the item template | |
158 | * in the template itself. | |
159 | */ | |
160 | if ((tag != -1) || opt) { | |
161 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE); | |
162 | goto err; | |
163 | } | |
9d6b1ce6 | 164 | return asn1_template_ex_d2i(pval, in, len, it->templates, opt, ctx); |
b31cc2d9 | 165 | } |
9d6b1ce6 DSH |
166 | return asn1_d2i_ex_primitive(pval, in, len, it, tag, aclass, opt, ctx); |
167 | break; | |
168 | ||
169 | case ASN1_ITYPE_MSTRING: | |
170 | p = *in; | |
171 | /* Just read in tag and class */ | |
172 | ret = asn1_check_tlen(NULL, &otag, &oclass, NULL, NULL, &p, len, -1, 0, 1, ctx); | |
173 | if(!ret) { | |
174 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
175 | goto err; | |
176 | } | |
177 | /* Must be UNIVERSAL class */ | |
178 | if(oclass != V_ASN1_UNIVERSAL) { | |
179 | /* If OPTIONAL, assume this is OK */ | |
180 | if(opt) return -1; | |
181 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_MSTRING_NOT_UNIVERSAL); | |
182 | goto err; | |
183 | } | |
184 | /* Check tag matches bit map */ | |
185 | if(!(ASN1_tag2bit(otag) & it->utype)) { | |
186 | /* If OPTIONAL, assume this is OK */ | |
187 | if(opt) return -1; | |
188 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_MSTRING_WRONG_TAG); | |
189 | goto err; | |
190 | } | |
191 | return asn1_d2i_ex_primitive(pval, in, len, it, otag, 0, 0, ctx); | |
192 | ||
193 | case ASN1_ITYPE_EXTERN: | |
194 | /* Use new style d2i */ | |
195 | ef = it->funcs; | |
196 | return ef->asn1_ex_d2i(pval, in, len, it, tag, aclass, opt, ctx); | |
197 | ||
198 | case ASN1_ITYPE_COMPAT: | |
199 | /* we must resort to old style evil hackery */ | |
200 | cf = it->funcs; | |
201 | ||
202 | /* If OPTIONAL see if it is there */ | |
203 | if(opt) { | |
204 | int exptag; | |
205 | p = *in; | |
206 | if(tag == -1) exptag = it->utype; | |
207 | else exptag = tag; | |
208 | /* Don't care about anything other than presence of expected tag */ | |
209 | ret = asn1_check_tlen(NULL, NULL, NULL, NULL, NULL, &p, len, exptag, aclass, 1, ctx); | |
210 | if(!ret) { | |
211 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
212 | goto err; | |
213 | } | |
214 | if(ret == -1) return -1; | |
215 | } | |
216 | /* This is the old style evil hack IMPLICIT handling: | |
217 | * since the underlying code is expecting a tag and | |
218 | * class other than the one present we change the | |
219 | * buffer temporarily then change it back afterwards. | |
220 | * This doesn't and never did work for tags > 30. | |
221 | * | |
222 | * Yes this is *horrible* but it is only needed for | |
223 | * old style d2i which will hopefully not be around | |
224 | * for much longer. | |
225 | * FIXME: should copy the buffer then modify it so | |
226 | * the input buffer can be const: we should *always* | |
227 | * copy because the old style d2i might modify the | |
228 | * buffer. | |
229 | */ | |
230 | ||
231 | if(tag != -1) { | |
232 | p = *in; | |
233 | imphack = *p; | |
3c07b4c2 | 234 | *p = (unsigned char)((*p & V_ASN1_CONSTRUCTED) | it->utype); |
9d6b1ce6 DSH |
235 | } |
236 | ||
237 | ptmpval = cf->asn1_d2i(pval, in, len); | |
238 | ||
239 | if(tag != -1) *p = imphack; | |
240 | ||
241 | if(ptmpval) return 1; | |
242 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
243 | goto err; | |
244 | ||
245 | ||
246 | case ASN1_ITYPE_CHOICE: | |
247 | if(asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it)) | |
248 | goto auxerr; | |
722ca278 DSH |
249 | |
250 | /* Allocate structure */ | |
251 | if(!*pval) { | |
252 | if(!ASN1_item_ex_new(pval, it)) { | |
722ca278 DSH |
253 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR); |
254 | goto err; | |
255 | } | |
256 | } | |
9d6b1ce6 DSH |
257 | /* CHOICE type, try each possibility in turn */ |
258 | pchval = NULL; | |
259 | p = *in; | |
260 | for(i = 0, tt=it->templates; i < it->tcount; i++, tt++) { | |
722ca278 | 261 | pchptr = asn1_get_field_ptr(pval, tt); |
9d6b1ce6 DSH |
262 | /* We mark field as OPTIONAL so its absence |
263 | * can be recognised. | |
264 | */ | |
722ca278 | 265 | ret = asn1_template_ex_d2i(pchptr, &p, len, tt, 1, ctx); |
9d6b1ce6 DSH |
266 | /* If field not present, try the next one */ |
267 | if(ret == -1) continue; | |
268 | /* If positive return, read OK, break loop */ | |
269 | if(ret > 0) break; | |
270 | /* Otherwise must be an ASN1 parsing error */ | |
271 | errtt = tt; | |
272 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
b31cc2d9 | 273 | goto err; |
9d6b1ce6 DSH |
274 | } |
275 | /* Did we fall off the end without reading anything? */ | |
276 | if(i == it->tcount) { | |
277 | /* If OPTIONAL, this is OK */ | |
722ca278 DSH |
278 | if(opt) { |
279 | /* Free and zero it */ | |
280 | ASN1_item_ex_free(pval, it); | |
281 | return -1; | |
282 | } | |
9d6b1ce6 | 283 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_NO_MATCHING_CHOICE_TYPE); |
b31cc2d9 | 284 | goto err; |
9d6b1ce6 | 285 | } |
9d6b1ce6 DSH |
286 | asn1_set_choice_selector(pval, i, it); |
287 | *in = p; | |
288 | if(asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it)) | |
289 | goto auxerr; | |
290 | return 1; | |
291 | ||
230fd6b7 | 292 | case ASN1_ITYPE_NDEF_SEQUENCE: |
9d6b1ce6 DSH |
293 | case ASN1_ITYPE_SEQUENCE: |
294 | p = *in; | |
295 | tmplen = len; | |
296 | ||
297 | /* If no IMPLICIT tagging set to SEQUENCE, UNIVERSAL */ | |
298 | if(tag == -1) { | |
299 | tag = V_ASN1_SEQUENCE; | |
300 | aclass = V_ASN1_UNIVERSAL; | |
301 | } | |
302 | /* Get SEQUENCE length and update len, p */ | |
303 | ret = asn1_check_tlen(&len, NULL, NULL, &seq_eoc, &cst, &p, len, tag, aclass, opt, ctx); | |
304 | if(!ret) { | |
305 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
306 | goto err; | |
307 | } else if(ret == -1) return -1; | |
308 | if(aux && (aux->flags & ASN1_AFLG_BROKEN)) { | |
309 | len = tmplen - (p - *in); | |
310 | seq_nolen = 1; | |
311 | } else seq_nolen = seq_eoc; /* If indefinite we don't do a length check */ | |
312 | if(!cst) { | |
313 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_SEQUENCE_NOT_CONSTRUCTED); | |
314 | goto err; | |
315 | } | |
316 | ||
317 | if(!*pval) { | |
318 | if(!ASN1_item_ex_new(pval, it)) { | |
319 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
320 | goto err; | |
321 | } | |
322 | } | |
323 | if(asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it)) | |
324 | goto auxerr; | |
325 | ||
326 | /* Get each field entry */ | |
327 | for(i = 0, tt = it->templates; i < it->tcount; i++, tt++) { | |
328 | const ASN1_TEMPLATE *seqtt; | |
329 | ASN1_VALUE **pseqval; | |
330 | seqtt = asn1_do_adb(pval, tt, 1); | |
331 | if(!seqtt) goto err; | |
332 | pseqval = asn1_get_field_ptr(pval, seqtt); | |
333 | /* Have we ran out of data? */ | |
334 | if(!len) break; | |
335 | q = p; | |
336 | if(asn1_check_eoc(&p, len)) { | |
337 | if(!seq_eoc) { | |
338 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_UNEXPECTED_EOC); | |
339 | goto err; | |
340 | } | |
341 | len -= p - q; | |
342 | seq_eoc = 0; | |
343 | q = p; | |
344 | break; | |
345 | } | |
346 | /* This determines the OPTIONAL flag value. The field cannot | |
347 | * be omitted if it is the last of a SEQUENCE and there is | |
348 | * still data to be read. This isn't strictly necessary but | |
349 | * it increases efficiency in some cases. | |
350 | */ | |
351 | if(i == (it->tcount - 1)) isopt = 0; | |
3c07b4c2 | 352 | else isopt = (char)(seqtt->flags & ASN1_TFLG_OPTIONAL); |
9d6b1ce6 DSH |
353 | /* attempt to read in field, allowing each to be OPTIONAL */ |
354 | ret = asn1_template_ex_d2i(pseqval, &p, len, seqtt, isopt, ctx); | |
355 | if(!ret) { | |
356 | errtt = seqtt; | |
357 | goto err; | |
358 | } else if(ret == -1) { | |
359 | /* OPTIONAL component absent. Free and zero the field | |
360 | */ | |
361 | ASN1_template_free(pseqval, seqtt); | |
362 | continue; | |
363 | } | |
364 | /* Update length */ | |
365 | len -= p - q; | |
366 | } | |
367 | /* Check for EOC if expecting one */ | |
368 | if(seq_eoc && !asn1_check_eoc(&p, len)) { | |
369 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_MISSING_EOC); | |
370 | goto err; | |
371 | } | |
372 | /* Check all data read */ | |
373 | if(!seq_nolen && len) { | |
374 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_SEQUENCE_LENGTH_MISMATCH); | |
375 | goto err; | |
376 | } | |
377 | ||
378 | /* If we get here we've got no more data in the SEQUENCE, | |
379 | * however we may not have read all fields so check all | |
380 | * remaining are OPTIONAL and clear any that are. | |
381 | */ | |
382 | for(; i < it->tcount; tt++, i++) { | |
383 | const ASN1_TEMPLATE *seqtt; | |
384 | seqtt = asn1_do_adb(pval, tt, 1); | |
385 | if(!seqtt) goto err; | |
386 | if(seqtt->flags & ASN1_TFLG_OPTIONAL) { | |
387 | ASN1_VALUE **pseqval; | |
388 | pseqval = asn1_get_field_ptr(pval, seqtt); | |
389 | ASN1_template_free(pseqval, seqtt); | |
390 | } else { | |
391 | errtt = seqtt; | |
392 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_FIELD_MISSING); | |
393 | goto err; | |
394 | } | |
395 | } | |
396 | /* Save encoding */ | |
397 | if(!asn1_enc_save(pval, *in, p - *in, it)) goto auxerr; | |
398 | *in = p; | |
399 | if(asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it)) | |
400 | goto auxerr; | |
401 | return 1; | |
402 | ||
403 | default: | |
404 | return 0; | |
405 | } | |
406 | auxerr: | |
407 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_AUX_ERROR); | |
408 | err: | |
409 | ASN1_item_ex_free(pval, it); | |
410 | if(errtt) ERR_add_error_data(4, "Field=", errtt->field_name, ", Type=", it->sname); | |
411 | else ERR_add_error_data(2, "Type=", it->sname); | |
412 | return 0; | |
413 | } | |
414 | ||
415 | /* Templates are handled with two separate functions. One handles any EXPLICIT tag and the other handles the | |
416 | * rest. | |
417 | */ | |
418 | ||
866eedb9 | 419 | static int asn1_template_ex_d2i(ASN1_VALUE **val, unsigned char **in, long inlen, const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx) |
9d6b1ce6 DSH |
420 | { |
421 | int flags, aclass; | |
422 | int ret; | |
423 | long len; | |
424 | unsigned char *p, *q; | |
425 | char exp_eoc; | |
426 | if(!val) return 0; | |
427 | flags = tt->flags; | |
428 | aclass = flags & ASN1_TFLG_TAG_CLASS; | |
429 | ||
430 | p = *in; | |
431 | ||
432 | /* Check if EXPLICIT tag expected */ | |
433 | if(flags & ASN1_TFLG_EXPTAG) { | |
434 | char cst; | |
435 | /* Need to work out amount of data available to the inner content and where it | |
436 | * starts: so read in EXPLICIT header to get the info. | |
437 | */ | |
438 | ret = asn1_check_tlen(&len, NULL, NULL, &exp_eoc, &cst, &p, inlen, tt->tag, aclass, opt, ctx); | |
439 | q = p; | |
440 | if(!ret) { | |
441 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
442 | return 0; | |
443 | } else if(ret == -1) return -1; | |
444 | if(!cst) { | |
445 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED); | |
446 | return 0; | |
447 | } | |
448 | /* We've found the field so it can't be OPTIONAL now */ | |
449 | ret = asn1_template_noexp_d2i(val, &p, len, tt, 0, ctx); | |
450 | if(!ret) { | |
451 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
452 | return 0; | |
453 | } | |
454 | /* We read the field in OK so update length */ | |
455 | len -= p - q; | |
456 | if(exp_eoc) { | |
457 | /* If NDEF we must have an EOC here */ | |
458 | if(!asn1_check_eoc(&p, len)) { | |
459 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ASN1_R_MISSING_EOC); | |
460 | goto err; | |
461 | } | |
462 | } else { | |
463 | /* Otherwise we must hit the EXPLICIT tag end or its an error */ | |
464 | if(len) { | |
465 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ASN1_R_EXPLICIT_LENGTH_MISMATCH); | |
466 | goto err; | |
467 | } | |
468 | } | |
469 | } else | |
470 | return asn1_template_noexp_d2i(val, in, inlen, tt, opt, ctx); | |
471 | ||
472 | *in = p; | |
473 | return 1; | |
474 | ||
475 | err: | |
476 | ASN1_template_free(val, tt); | |
477 | *val = NULL; | |
478 | return 0; | |
479 | } | |
480 | ||
481 | static int asn1_template_noexp_d2i(ASN1_VALUE **val, unsigned char **in, long len, const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx) | |
482 | { | |
483 | int flags, aclass; | |
484 | int ret; | |
485 | unsigned char *p, *q; | |
486 | if(!val) return 0; | |
487 | flags = tt->flags; | |
488 | aclass = flags & ASN1_TFLG_TAG_CLASS; | |
489 | ||
490 | p = *in; | |
491 | q = p; | |
492 | ||
493 | if(flags & ASN1_TFLG_SK_MASK) { | |
494 | /* SET OF, SEQUENCE OF */ | |
495 | int sktag, skaclass; | |
496 | char sk_eoc; | |
497 | /* First work out expected inner tag value */ | |
498 | if(flags & ASN1_TFLG_IMPTAG) { | |
499 | sktag = tt->tag; | |
500 | skaclass = aclass; | |
501 | } else { | |
502 | skaclass = V_ASN1_UNIVERSAL; | |
503 | if(flags & ASN1_TFLG_SET_OF) sktag = V_ASN1_SET; | |
504 | else sktag = V_ASN1_SEQUENCE; | |
505 | } | |
506 | /* Get the tag */ | |
507 | ret = asn1_check_tlen(&len, NULL, NULL, &sk_eoc, NULL, &p, len, sktag, skaclass, opt, ctx); | |
508 | if(!ret) { | |
509 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | |
510 | return 0; | |
511 | } else if(ret == -1) return -1; | |
512 | if(!*val) *val = (ASN1_VALUE *)sk_new_null(); | |
513 | else { | |
514 | /* We've got a valid STACK: free up any items present */ | |
515 | STACK *sktmp = (STACK *)*val; | |
516 | ASN1_VALUE *vtmp; | |
517 | while(sk_num(sktmp) > 0) { | |
518 | vtmp = (ASN1_VALUE *)sk_pop(sktmp); | |
bb5ea36b | 519 | ASN1_item_ex_free(&vtmp, ASN1_ITEM_ptr(tt->item)); |
9d6b1ce6 DSH |
520 | } |
521 | } | |
522 | ||
523 | if(!*val) { | |
524 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, ERR_R_MALLOC_FAILURE); | |
525 | goto err; | |
526 | } | |
527 | /* Read as many items as we can */ | |
528 | while(len > 0) { | |
529 | ASN1_VALUE *skfield; | |
530 | q = p; | |
531 | /* See if EOC found */ | |
532 | if(asn1_check_eoc(&p, len)) { | |
533 | if(!sk_eoc) { | |
534 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ASN1_R_UNEXPECTED_EOC); | |
535 | goto err; | |
536 | } | |
537 | len -= p - q; | |
538 | sk_eoc = 0; | |
539 | break; | |
540 | } | |
541 | skfield = NULL; | |
bb5ea36b | 542 | if(!ASN1_item_ex_d2i(&skfield, &p, len, ASN1_ITEM_ptr(tt->item), -1, 0, 0, ctx)) { |
9d6b1ce6 DSH |
543 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ERR_R_NESTED_ASN1_ERROR); |
544 | goto err; | |
545 | } | |
546 | len -= p - q; | |
547 | if(!sk_push((STACK *)*val, (char *)skfield)) { | |
548 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ERR_R_MALLOC_FAILURE); | |
549 | goto err; | |
550 | } | |
551 | } | |
552 | if(sk_eoc) { | |
553 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ASN1_R_MISSING_EOC); | |
554 | goto err; | |
555 | } | |
556 | } else if(flags & ASN1_TFLG_IMPTAG) { | |
557 | /* IMPLICIT tagging */ | |
bb5ea36b | 558 | ret = ASN1_item_ex_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item), tt->tag, aclass, opt, ctx); |
9d6b1ce6 DSH |
559 | if(!ret) { |
560 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ERR_R_NESTED_ASN1_ERROR); | |
561 | goto err; | |
562 | } else if(ret == -1) return -1; | |
563 | } else { | |
564 | /* Nothing special */ | |
bb5ea36b | 565 | ret = ASN1_item_ex_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item), -1, 0, opt, ctx); |
9d6b1ce6 DSH |
566 | if(!ret) { |
567 | ASN1err(ASN1_F_ASN1_TEMPLATE_D2I, ERR_R_NESTED_ASN1_ERROR); | |
568 | goto err; | |
569 | } else if(ret == -1) return -1; | |
570 | } | |
571 | ||
572 | *in = p; | |
573 | return 1; | |
574 | ||
575 | err: | |
576 | ASN1_template_free(val, tt); | |
577 | *val = NULL; | |
578 | return 0; | |
579 | } | |
580 | ||
581 | static int asn1_d2i_ex_primitive(ASN1_VALUE **pval, unsigned char **in, long inlen, | |
582 | const ASN1_ITEM *it, | |
583 | int tag, int aclass, char opt, ASN1_TLC *ctx) | |
584 | { | |
585 | int ret = 0, utype; | |
586 | long plen; | |
587 | char cst, inf, free_cont = 0; | |
588 | unsigned char *p; | |
589 | BUF_MEM buf; | |
590 | unsigned char *cont = NULL; | |
591 | long len; | |
592 | if(!pval) { | |
593 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_NULL); | |
594 | return 0; /* Should never happen */ | |
595 | } | |
596 | ||
597 | if(it->itype == ASN1_ITYPE_MSTRING) { | |
598 | utype = tag; | |
599 | tag = -1; | |
600 | } else utype = it->utype; | |
601 | ||
602 | if(utype == V_ASN1_ANY) { | |
603 | /* If type is ANY need to figure out type from tag */ | |
604 | unsigned char oclass; | |
605 | if(tag >= 0) { | |
606 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_TAGGED_ANY); | |
607 | return 0; | |
608 | } | |
609 | if(opt) { | |
610 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_OPTIONAL_ANY); | |
611 | return 0; | |
612 | } | |
613 | p = *in; | |
614 | ret = asn1_check_tlen(NULL, &utype, &oclass, NULL, NULL, &p, inlen, -1, 0, 0, ctx); | |
615 | if(!ret) { | |
616 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_NESTED_ASN1_ERROR); | |
617 | return 0; | |
618 | } | |
619 | if(oclass != V_ASN1_UNIVERSAL) utype = V_ASN1_OTHER; | |
620 | } | |
621 | if(tag == -1) { | |
622 | tag = utype; | |
623 | aclass = V_ASN1_UNIVERSAL; | |
624 | } | |
625 | p = *in; | |
626 | /* Check header */ | |
627 | ret = asn1_check_tlen(&plen, NULL, NULL, &inf, &cst, &p, inlen, tag, aclass, opt, ctx); | |
628 | if(!ret) { | |
629 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_NESTED_ASN1_ERROR); | |
630 | return 0; | |
631 | } else if(ret == -1) return -1; | |
632 | /* SEQUENCE, SET and "OTHER" are left in encoded form */ | |
633 | if((utype == V_ASN1_SEQUENCE) || (utype == V_ASN1_SET) || (utype == V_ASN1_OTHER)) { | |
c962479b DSH |
634 | /* Clear context cache for type OTHER because the auto clear when |
635 | * we have a exact match wont work | |
636 | */ | |
637 | if(utype == V_ASN1_OTHER) { | |
638 | asn1_tlc_clear(ctx); | |
9d6b1ce6 | 639 | /* SEQUENCE and SET must be constructed */ |
c962479b | 640 | } else if(!cst) { |
9d6b1ce6 DSH |
641 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_TYPE_NOT_CONSTRUCTED); |
642 | return 0; | |
643 | } | |
644 | ||
645 | cont = *in; | |
646 | /* If indefinite length constructed find the real end */ | |
647 | if(inf) { | |
bf0d176e | 648 | if(!asn1_collect(NULL, &p, plen, inf, -1, -1)) goto err; |
9d6b1ce6 DSH |
649 | len = p - cont; |
650 | } else { | |
651 | len = p - cont + plen; | |
652 | p += plen; | |
653 | buf.data = NULL; | |
654 | } | |
655 | } else if(cst) { | |
656 | buf.length = 0; | |
657 | buf.max = 0; | |
658 | buf.data = NULL; | |
659 | /* Should really check the internal tags are correct but | |
660 | * some things may get this wrong. The relevant specs | |
661 | * say that constructed string types should be OCTET STRINGs | |
662 | * internally irrespective of the type. So instead just check | |
663 | * for UNIVERSAL class and ignore the tag. | |
664 | */ | |
bf0d176e | 665 | if(!asn1_collect(&buf, &p, plen, inf, -1, V_ASN1_UNIVERSAL)) goto err; |
9d6b1ce6 | 666 | len = buf.length; |
bf0d176e | 667 | /* Append a final null to string */ |
54a656ef | 668 | if(!BUF_MEM_grow_clean(&buf, len + 1)) { |
bf0d176e DSH |
669 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_MALLOC_FAILURE); |
670 | return 0; | |
671 | } | |
672 | buf.data[len] = 0; | |
673 | cont = (unsigned char *)buf.data; | |
9d6b1ce6 DSH |
674 | free_cont = 1; |
675 | } else { | |
676 | cont = p; | |
677 | len = plen; | |
678 | p += plen; | |
679 | } | |
680 | ||
681 | /* We now have content length and type: translate into a structure */ | |
682 | if(!asn1_ex_c2i(pval, cont, len, utype, &free_cont, it)) goto err; | |
683 | ||
684 | *in = p; | |
685 | ret = 1; | |
686 | err: | |
687 | if(free_cont && buf.data) OPENSSL_free(buf.data); | |
688 | return ret; | |
689 | } | |
690 | ||
691 | /* Translate ASN1 content octets into a structure */ | |
692 | ||
693 | int asn1_ex_c2i(ASN1_VALUE **pval, unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it) | |
694 | { | |
695 | ASN1_STRING *stmp; | |
696 | ASN1_TYPE *typ = NULL; | |
697 | int ret = 0; | |
698 | const ASN1_PRIMITIVE_FUNCS *pf; | |
a8312c0e | 699 | ASN1_INTEGER **tint; |
9d6b1ce6 DSH |
700 | pf = it->funcs; |
701 | if(pf && pf->prim_c2i) return pf->prim_c2i(pval, cont, len, utype, free_cont, it); | |
702 | /* If ANY type clear type and set pointer to internal value */ | |
703 | if(it->utype == V_ASN1_ANY) { | |
704 | if(!*pval) { | |
705 | typ = ASN1_TYPE_new(); | |
706 | *pval = (ASN1_VALUE *)typ; | |
ecbe0781 | 707 | } else typ = (ASN1_TYPE *)*pval; |
9d6b1ce6 DSH |
708 | if(utype != typ->type) ASN1_TYPE_set(typ, utype, NULL); |
709 | pval = (ASN1_VALUE **)&typ->value.ptr; | |
710 | } | |
711 | switch(utype) { | |
712 | case V_ASN1_OBJECT: | |
713 | if(!c2i_ASN1_OBJECT((ASN1_OBJECT **)pval, &cont, len)) goto err; | |
714 | break; | |
715 | ||
716 | case V_ASN1_NULL: | |
717 | if(len) { | |
718 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_NULL_IS_WRONG_LENGTH); | |
719 | goto err; | |
720 | } | |
721 | *pval = (ASN1_VALUE *)1; | |
722 | break; | |
723 | ||
724 | case V_ASN1_BOOLEAN: | |
725 | if(len != 1) { | |
726 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_BOOLEAN_IS_WRONG_LENGTH); | |
727 | goto err; | |
728 | } else { | |
729 | ASN1_BOOLEAN *tbool; | |
730 | tbool = (ASN1_BOOLEAN *)pval; | |
731 | *tbool = *cont; | |
732 | } | |
733 | break; | |
734 | ||
735 | case V_ASN1_BIT_STRING: | |
736 | if(!c2i_ASN1_BIT_STRING((ASN1_BIT_STRING **)pval, &cont, len)) goto err; | |
737 | break; | |
738 | ||
739 | case V_ASN1_INTEGER: | |
740 | case V_ASN1_NEG_INTEGER: | |
741 | case V_ASN1_ENUMERATED: | |
742 | case V_ASN1_NEG_ENUMERATED: | |
a8312c0e DSH |
743 | tint = (ASN1_INTEGER **)pval; |
744 | if(!c2i_ASN1_INTEGER(tint, &cont, len)) goto err; | |
745 | /* Fixup type to match the expected form */ | |
746 | (*tint)->type = utype | ((*tint)->type & V_ASN1_NEG); | |
9d6b1ce6 DSH |
747 | break; |
748 | ||
749 | case V_ASN1_OCTET_STRING: | |
750 | case V_ASN1_NUMERICSTRING: | |
751 | case V_ASN1_PRINTABLESTRING: | |
752 | case V_ASN1_T61STRING: | |
753 | case V_ASN1_VIDEOTEXSTRING: | |
754 | case V_ASN1_IA5STRING: | |
755 | case V_ASN1_UTCTIME: | |
756 | case V_ASN1_GENERALIZEDTIME: | |
757 | case V_ASN1_GRAPHICSTRING: | |
758 | case V_ASN1_VISIBLESTRING: | |
759 | case V_ASN1_GENERALSTRING: | |
760 | case V_ASN1_UNIVERSALSTRING: | |
761 | case V_ASN1_BMPSTRING: | |
762 | case V_ASN1_UTF8STRING: | |
763 | case V_ASN1_OTHER: | |
764 | case V_ASN1_SET: | |
765 | case V_ASN1_SEQUENCE: | |
766 | default: | |
767 | /* All based on ASN1_STRING and handled the same */ | |
768 | if(!*pval) { | |
769 | stmp = ASN1_STRING_type_new(utype); | |
770 | if(!stmp) { | |
771 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_MALLOC_FAILURE); | |
772 | goto err; | |
773 | } | |
774 | *pval = (ASN1_VALUE *)stmp; | |
775 | } else { | |
776 | stmp = (ASN1_STRING *)*pval; | |
777 | stmp->type = utype; | |
778 | } | |
779 | /* If we've already allocated a buffer use it */ | |
780 | if(*free_cont) { | |
781 | if(stmp->data) OPENSSL_free(stmp->data); | |
782 | stmp->data = cont; | |
783 | stmp->length = len; | |
784 | *free_cont = 0; | |
785 | } else { | |
786 | if(!ASN1_STRING_set(stmp, cont, len)) { | |
787 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_MALLOC_FAILURE); | |
788 | ASN1_STRING_free(stmp); | |
789 | *pval = NULL; | |
790 | goto err; | |
791 | } | |
792 | } | |
793 | break; | |
794 | } | |
795 | /* If ASN1_ANY and NULL type fix up value */ | |
796 | if(typ && utype==V_ASN1_NULL) typ->value.ptr = NULL; | |
797 | ||
798 | ret = 1; | |
799 | err: | |
800 | if(!ret) ASN1_TYPE_free(typ); | |
801 | return ret; | |
802 | } | |
803 | ||
804 | /* This function collects the asn1 data from a constructred string | |
805 | * type into a buffer. The values of 'in' and 'len' should refer | |
806 | * to the contents of the constructed type and 'inf' should be set | |
807 | * if it is indefinite length. If 'buf' is NULL then we just want | |
808 | * to find the end of the current structure: useful for indefinite | |
809 | * length constructed stuff. | |
810 | */ | |
811 | ||
812 | static int asn1_collect(BUF_MEM *buf, unsigned char **in, long len, char inf, int tag, int aclass) | |
813 | { | |
814 | unsigned char *p, *q; | |
815 | long plen; | |
816 | char cst, ininf; | |
817 | p = *in; | |
818 | inf &= 1; | |
819 | /* If no buffer and not indefinite length constructed just pass over the encoded data */ | |
820 | if(!buf && !inf) { | |
821 | *in += len; | |
822 | return 1; | |
823 | } | |
824 | while(len > 0) { | |
825 | q = p; | |
826 | /* Check for EOC */ | |
827 | if(asn1_check_eoc(&p, len)) { | |
828 | /* EOC is illegal outside indefinite length constructed form */ | |
829 | if(!inf) { | |
830 | ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_UNEXPECTED_EOC); | |
831 | return 0; | |
832 | } | |
833 | inf = 0; | |
834 | break; | |
835 | } | |
836 | if(!asn1_check_tlen(&plen, NULL, NULL, &ininf, &cst, &p, len, tag, aclass, 0, NULL)) { | |
837 | ASN1err(ASN1_F_ASN1_COLLECT, ERR_R_NESTED_ASN1_ERROR); | |
838 | return 0; | |
839 | } | |
840 | /* If indefinite length constructed update max length */ | |
841 | if(cst) { | |
842 | if(!asn1_collect(buf, &p, plen, ininf, tag, aclass)) return 0; | |
843 | } else { | |
844 | if(!collect_data(buf, &p, plen)) return 0; | |
845 | } | |
846 | len -= p - q; | |
847 | } | |
848 | if(inf) { | |
849 | ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_MISSING_EOC); | |
850 | return 0; | |
851 | } | |
852 | *in = p; | |
853 | return 1; | |
854 | } | |
855 | ||
856 | static int collect_data(BUF_MEM *buf, unsigned char **p, long plen) | |
857 | { | |
858 | int len; | |
859 | if(buf) { | |
860 | len = buf->length; | |
54a656ef | 861 | if(!BUF_MEM_grow_clean(buf, len + plen)) { |
9d6b1ce6 DSH |
862 | ASN1err(ASN1_F_COLLECT_DATA, ERR_R_MALLOC_FAILURE); |
863 | return 0; | |
864 | } | |
865 | memcpy(buf->data + len, *p, plen); | |
866 | } | |
867 | *p += plen; | |
868 | return 1; | |
869 | } | |
870 | ||
871 | /* Check for ASN1 EOC and swallow it if found */ | |
872 | ||
873 | static int asn1_check_eoc(unsigned char **in, long len) | |
874 | { | |
875 | unsigned char *p; | |
876 | if(len < 2) return 0; | |
877 | p = *in; | |
878 | if(!p[0] && !p[1]) { | |
879 | *in += 2; | |
880 | return 1; | |
881 | } | |
882 | return 0; | |
883 | } | |
884 | ||
885 | /* Check an ASN1 tag and length: a bit like ASN1_get_object | |
886 | * but it sets the length for indefinite length constructed | |
887 | * form, we don't know the exact length but we can set an | |
888 | * upper bound to the amount of data available minus the | |
889 | * header length just read. | |
890 | */ | |
891 | ||
892 | static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass, char *inf, char *cst, | |
893 | unsigned char **in, long len, int exptag, int expclass, char opt, ASN1_TLC *ctx) | |
894 | { | |
895 | int i; | |
896 | int ptag, pclass; | |
897 | long plen; | |
898 | unsigned char *p, *q; | |
899 | p = *in; | |
900 | q = p; | |
901 | ||
902 | if(ctx && ctx->valid) { | |
903 | i = ctx->ret; | |
904 | plen = ctx->plen; | |
905 | pclass = ctx->pclass; | |
906 | ptag = ctx->ptag; | |
907 | p += ctx->hdrlen; | |
908 | } else { | |
909 | i = ASN1_get_object(&p, &plen, &ptag, &pclass, len); | |
910 | if(ctx) { | |
911 | ctx->ret = i; | |
912 | ctx->plen = plen; | |
913 | ctx->pclass = pclass; | |
914 | ctx->ptag = ptag; | |
915 | ctx->hdrlen = p - q; | |
916 | ctx->valid = 1; | |
41ab00be DSH |
917 | /* If definite length, and no error, length + |
918 | * header can't exceed total amount of data available. | |
ecbe0781 | 919 | */ |
41ab00be | 920 | if(!(i & 0x81) && ((plen + ctx->hdrlen) > len)) { |
ecbe0781 DSH |
921 | ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_TOO_LONG); |
922 | asn1_tlc_clear(ctx); | |
923 | return 0; | |
924 | } | |
9d6b1ce6 DSH |
925 | } |
926 | } | |
c962479b | 927 | |
9d6b1ce6 DSH |
928 | if(i & 0x80) { |
929 | ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_BAD_OBJECT_HEADER); | |
930 | asn1_tlc_clear(ctx); | |
931 | return 0; | |
932 | } | |
933 | if(exptag >= 0) { | |
934 | if((exptag != ptag) || (expclass != pclass)) { | |
935 | /* If type is OPTIONAL, not an error, but indicate missing | |
936 | * type. | |
937 | */ | |
938 | if(opt) return -1; | |
939 | asn1_tlc_clear(ctx); | |
940 | ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_WRONG_TAG); | |
941 | return 0; | |
942 | } | |
943 | /* We have a tag and class match, so assume we are going to do something with it */ | |
944 | asn1_tlc_clear(ctx); | |
945 | } | |
946 | ||
947 | if(i & 1) plen = len - (p - q); | |
948 | ||
949 | if(inf) *inf = i & 1; | |
950 | ||
951 | if(cst) *cst = i & V_ASN1_CONSTRUCTED; | |
952 | ||
953 | if(olen) *olen = plen; | |
954 | if(oclass) *oclass = pclass; | |
955 | if(otag) *otag = ptag; | |
956 | ||
957 | *in = p; | |
958 | return 1; | |
959 | } |