?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix memset
[heimdal.git] / lib / asn1 / template.c
blobd3b2c07f0012da9dda1ef5465f0f0fc3c310d9d0
1 /*
2 * Copyright (c) 2009 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Portions Copyright (c) 2009 Apple Inc. 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 the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the Institute nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #include "der_locl.h"
37 #include <com_err.h>
38
39 #if 0
40 #define ABORT_ON_ERROR() abort()
41 #else
42 #define ABORT_ON_ERROR() do { } while(0)
43 #endif
44
45 #define DPOC(data,offset) ((const void *)(((const unsigned char *)data) + offset))
46 #define DPO(data,offset) ((void *)(((unsigned char *)data) + offset))
47
48
49 static struct asn1_type_func prim[] = {
50 #define el(name, type) { \
51 (asn1_type_encode)der_put_##name, \
52 (asn1_type_decode)der_get_##name, \
53 (asn1_type_length)der_length_##name, \
54 (asn1_type_copy)der_copy_##name, \
55 (asn1_type_release)der_free_##name, \
56 sizeof(type) \
57 }
58 #define elber(name, type) { \
59 (asn1_type_encode)der_put_##name, \
60 (asn1_type_decode)der_get_##name##_ber, \
61 (asn1_type_length)der_length_##name, \
62 (asn1_type_copy)der_copy_##name, \
63 (asn1_type_release)der_free_##name, \
64 sizeof(type) \
65 }
66 el(integer, int),
67 el(heim_integer, heim_integer),
68 el(integer, int),
69 el(integer64, int64_t),
70 el(unsigned, unsigned),
71 el(unsigned64, uint64_t),
72 el(general_string, heim_general_string),
73 el(octet_string, heim_octet_string),
74 elber(octet_string, heim_octet_string),
75 el(ia5_string, heim_ia5_string),
76 el(bmp_string, heim_bmp_string),
77 el(universal_string, heim_universal_string),
78 el(printable_string, heim_printable_string),
79 el(visible_string, heim_visible_string),
80 el(utf8string, heim_utf8_string),
81 el(generalized_time, time_t),
82 el(utctime, time_t),
83 el(bit_string, heim_bit_string),
84 { (asn1_type_encode)der_put_boolean, (asn1_type_decode)der_get_boolean,
85 (asn1_type_length)der_length_boolean, (asn1_type_copy)der_copy_integer,
86 (asn1_type_release)der_free_integer, sizeof(int)
87 },
88 el(oid, heim_oid),
89 el(general_string, heim_general_string),
90 #undef el
91 #undef elber
92 };
93
94 static size_t
95 sizeofType(const struct asn1_template *t)
96 {
97 return t->offset;
98 }
99
100 /*
101 * Here is abstraction to not so well evil fact of bit fields in C,
102 * they are endian dependent, so when getting and setting bits in the
103 * host local structure we need to know the endianness of the host.
104 *
105 * Its not the first time in Heimdal this have bitten us, and some day
106 * we'll grow up and use #defined constant, but bit fields are still
107 * so pretty and shiny.
108 */
109
110 static void
111 bmember_get_bit(const unsigned char *p, void *data,
112 unsigned int bit, size_t size)
113 {
114 unsigned int localbit = bit % 8;
115 if ((*p >> (7 - localbit)) & 1) {
116 #ifdef WORDS_BIGENDIAN
117 *(unsigned int *)data |= (1 << ((size * 8) - bit - 1));
118 #else
119 *(unsigned int *)data |= (1 << bit);
120 #endif
121 }
122 }
123
124 static int
125 bmember_isset_bit(const void *data, unsigned int bit, size_t size)
126 {
127 #ifdef WORDS_BIGENDIAN
128 if ((*(unsigned int *)data) & (1 << ((size * 8) - bit - 1)))
129 return 1;
130 return 0;
131 #else
132 if ((*(unsigned int *)data) & (1 << bit))
133 return 1;
134 return 0;
135 #endif
136 }
137
138 static void
139 bmember_put_bit(unsigned char *p, const void *data, unsigned int bit,
140 size_t size, unsigned int *bitset)
141 {
142 unsigned int localbit = bit % 8;
143
144 if (bmember_isset_bit(data, bit, size)) {
145 *p |= (1 << (7 - localbit));
146 if (*bitset == 0)
147 *bitset = (7 - localbit) + 1;
148 }
149 }
150
151 int
152 _asn1_decode(const struct asn1_template *t, unsigned flags,
153 const unsigned char *p, size_t len, void *data, size_t *retsize)
154 {
155 size_t elements = A1_HEADER_LEN(t);
156 size_t oldlen = len;
157 int ret = 0;
158 const unsigned char *startp = NULL;
159 unsigned int template_flags = t->tt;
160
161 /* skip over header */
162 t++;
163
164 if (template_flags & A1_HF_PRESERVE)
165 startp = p;
166
167 while (elements) {
168 switch (t->tt & A1_OP_MASK) {
169 case A1_OP_TYPE:
170 case A1_OP_TYPE_EXTERN: {
171 size_t newsize, size;
172 void *el = DPO(data, t->offset);
173 void **pel = (void **)el;
174
175 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
176 size = sizeofType(t->ptr);
177 } else {
178 const struct asn1_type_func *f = t->ptr;
179 size = f->size;
180 }
181
182 if (t->tt & A1_FLAG_OPTIONAL) {
183 *pel = calloc(1, size);
184 if (*pel == NULL)
185 return ENOMEM;
186 el = *pel;
187 }
188 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
189 ret = _asn1_decode(t->ptr, flags, p, len, el, &newsize);
190 } else {
191 const struct asn1_type_func *f = t->ptr;
192 ret = (f->decode)(p, len, el, &newsize);
193 }
194 if (ret) {
195 if (t->tt & A1_FLAG_OPTIONAL) {
196 free(*pel);
197 *pel = NULL;
198 break;
199 }
200 return ret;
201 }
202 p += newsize; len -= newsize;
203
204 break;
205 }
206 case A1_OP_TAG: {
207 Der_type dertype;
208 size_t newsize;
209 size_t datalen, l;
210 void *olddata = data;
211 int is_indefinite = 0;
212 int subflags = flags;
213
214 ret = der_match_tag_and_length(p, len, A1_TAG_CLASS(t->tt),
215 &dertype, A1_TAG_TAG(t->tt),
216 &datalen, &l);
217 if (ret) {
218 if (t->tt & A1_FLAG_OPTIONAL)
219 break;
220 return ret;
221 }
222
223 p += l; len -= l;
224
225 /*
226 * Only allow indefinite encoding for OCTET STRING and BER
227 * for now. Should handle BIT STRING too.
228 */
229
230 if (dertype != A1_TAG_TYPE(t->tt) && (flags & A1_PF_ALLOW_BER)) {
231 const struct asn1_template *subtype = t->ptr;
232 subtype++; /* skip header */
233
234 if (((subtype->tt & A1_OP_MASK) == A1_OP_PARSE) &&
235 A1_PARSE_TYPE(subtype->tt) == A1T_OCTET_STRING)
236 subflags |= A1_PF_INDEFINTE;
237 }
238
239 if (datalen == ASN1_INDEFINITE) {
240 if ((flags & A1_PF_ALLOW_BER) == 0)
241 return ASN1_GOT_BER;
242 is_indefinite = 1;
243 datalen = len;
244 if (datalen < 2)
245 return ASN1_OVERRUN;
246 /* hide EndOfContent for sub-decoder, catching it below */
247 datalen -= 2;
248 } else if (datalen > len)
249 return ASN1_OVERRUN;
250
251 data = DPO(data, t->offset);
252
253 if (t->tt & A1_FLAG_OPTIONAL) {
254 void **el = (void **)data;
255 size_t ellen = sizeofType(t->ptr);
256
257 *el = calloc(1, ellen);
258 if (*el == NULL)
259 return ENOMEM;
260 data = *el;
261 }
262
263 ret = _asn1_decode(t->ptr, subflags, p, datalen, data, &newsize);
264 if (ret)
265 return ret;
266
267 if (newsize != datalen)
268 return ASN1_EXTRA_DATA;
269
270 len -= datalen;
271 p += datalen;
272
273 /*
274 * Indefinite encoding needs a trailing EndOfContent,
275 * check for that.
276 */
277 if (is_indefinite) {
278 ret = der_match_tag_and_length(p, len, ASN1_C_UNIV,
279 &dertype, UT_EndOfContent,
280 &datalen, &l);
281 if (ret)
282 return ret;
283 if (dertype != PRIM)
284 return ASN1_BAD_ID;
285 if (datalen != 0)
286 return ASN1_INDEF_EXTRA_DATA;
287 p += l; len -= l;
288 }
289 data = olddata;
290
291 break;
292 }
293 case A1_OP_PARSE: {
294 unsigned int type = A1_PARSE_TYPE(t->tt);
295 size_t newsize;
296 void *el = DPO(data, t->offset);
297
298 /*
299 * INDEFINITE primitive types are one element after the
300 * same type but non-INDEFINITE version.
301 */
302 if (flags & A1_PF_INDEFINTE)
303 type++;
304
305 if (type >= sizeof(prim)/sizeof(prim[0])) {
306 ABORT_ON_ERROR();
307 return ASN1_PARSE_ERROR;
308 }
309
310 ret = (prim[type].decode)(p, len, el, &newsize);
311 if (ret)
312 return ret;
313 p += newsize; len -= newsize;
314
315 break;
316 }
317 case A1_OP_SETOF:
318 case A1_OP_SEQOF: {
319 struct template_of *el = DPO(data, t->offset);
320 size_t newsize;
321 size_t ellen = sizeofType(t->ptr);
322 size_t vallength = 0;
323
324 while (len > 0) {
325 void *tmp;
326 size_t newlen = vallength + ellen;
327 if (vallength > newlen)
328 return ASN1_OVERFLOW;
329
330 tmp = realloc(el->val, newlen);
331 if (tmp == NULL)
332 return ENOMEM;
333
334 memset(DPO(tmp, vallength), 0, ellen);
335 el->val = tmp;
336
337 ret = _asn1_decode(t->ptr, flags & (~A1_PF_INDEFINTE), p, len,
338 DPO(el->val, vallength), &newsize);
339 if (ret)
340 return ret;
341 vallength = newlen;
342 el->len++;
343 p += newsize; len -= newsize;
344 }
345
346 break;
347 }
348 case A1_OP_BMEMBER: {
349 const struct asn1_template *bmember = t->ptr;
350 size_t size = bmember->offset;
351 size_t els = A1_HEADER_LEN(bmember);
352 size_t pos = 0;
353
354 bmember++;
355
356 memset(data, 0, size);
357
358 if (len < 1)
359 return ASN1_OVERRUN;
360 p++; len--;
361
362 while (els && len) {
363 while (bmember->offset / 8 > pos / 8) {
364 if (len < 1)
365 break;
366 p++; len--;
367 pos += 8;
368 }
369 if (len) {
370 bmember_get_bit(p, data, bmember->offset, size);
371 els--; bmember++;
372 }
373 }
374 len = 0;
375 break;
376 }
377 case A1_OP_CHOICE: {
378 const struct asn1_template *choice = t->ptr;
379 unsigned int *element = DPO(data, choice->offset);
380 size_t datalen;
381 unsigned int i;
382
383 for (i = 1; i < A1_HEADER_LEN(choice) + 1; i++) {
384 /* should match first tag instead, store it in choice.tt */
385 ret = _asn1_decode(choice[i].ptr, 0, p, len,
386 DPO(data, choice[i].offset), &datalen);
387 if (ret == 0) {
388 *element = i;
389 p += datalen; len -= datalen;
390 break;
391 } else if (ret != ASN1_BAD_ID && ret != ASN1_MISPLACED_FIELD && ret != ASN1_MISSING_FIELD) {
392 return ret;
393 }
394 }
395 if (i >= A1_HEADER_LEN(choice) + 1) {
396 if (choice->tt == 0)
397 return ASN1_BAD_ID;
398
399 *element = 0;
400 ret = der_get_octet_string(p, len,
401 DPO(data, choice->tt), &datalen);
402 if (ret)
403 return ret;
404 p += datalen; len -= datalen;
405 }
406
407 break;
408 }
409 default:
410 ABORT_ON_ERROR();
411 return ASN1_PARSE_ERROR;
412 }
413 t++;
414 elements--;
415 }
416 /* if we are using padding, eat up read of context */
417 if (template_flags & A1_HF_ELLIPSIS)
418 len = 0;
419
420 oldlen -= len;
421
422 if (retsize)
423 *retsize = oldlen;
424
425 /*
426 * saved the raw bits if asked for it, useful for signature
427 * verification.
428 */
429 if (startp) {
430 heim_octet_string *save = data;
431
432 save->data = malloc(oldlen);
433 if (save->data == NULL)
434 return ENOMEM;
435 else {
436 save->length = oldlen;
437 memcpy(save->data, startp, oldlen);
438 }
439 }
440 return 0;
441 }
442
443 int
444 _asn1_encode(const struct asn1_template *t, unsigned char *p, size_t len,
445 const void *data, size_t *retsize)
446 {
447 size_t elements = A1_HEADER_LEN(t);
448 int ret = 0;
449 size_t oldlen = len;
450
451 t += A1_HEADER_LEN(t);
452
453 while (elements) {
454 switch (t->tt & A1_OP_MASK) {
455 case A1_OP_TYPE:
456 case A1_OP_TYPE_EXTERN: {
457 size_t newsize;
458 const void *el = DPOC(data, t->offset);
459
460 if (t->tt & A1_FLAG_OPTIONAL) {
461 void **pel = (void **)el;
462 if (*pel == NULL)
463 break;
464 el = *pel;
465 }
466
467 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
468 ret = _asn1_encode(t->ptr, p, len, el, &newsize);
469 } else {
470 const struct asn1_type_func *f = t->ptr;
471 ret = (f->encode)(p, len, el, &newsize);
472 }
473
474 if (ret)
475 return ret;
476 p -= newsize; len -= newsize;
477
478 break;
479 }
480 case A1_OP_TAG: {
481 const void *olddata = data;
482 size_t l, datalen;
483
484 data = DPOC(data, t->offset);
485
486 if (t->tt & A1_FLAG_OPTIONAL) {
487 void **el = (void **)data;
488 if (*el == NULL) {
489 data = olddata;
490 break;
491 }
492 data = *el;
493 }
494
495 ret = _asn1_encode(t->ptr, p, len, data, &datalen);
496 if (ret)
497 return ret;
498
499 len -= datalen; p -= datalen;
500
501 ret = der_put_length_and_tag(p, len, datalen,
502 A1_TAG_CLASS(t->tt),
503 A1_TAG_TYPE(t->tt),
504 A1_TAG_TAG(t->tt), &l);
505 if (ret)
506 return ret;
507
508 p -= l; len -= l;
509
510 data = olddata;
511
512 break;
513 }
514 case A1_OP_PARSE: {
515 unsigned int type = A1_PARSE_TYPE(t->tt);
516 size_t newsize;
517 const void *el = DPOC(data, t->offset);
518
519 if (type > sizeof(prim)/sizeof(prim[0])) {
520 ABORT_ON_ERROR();
521 return ASN1_PARSE_ERROR;
522 }
523
524 ret = (prim[type].encode)(p, len, el, &newsize);
525 if (ret)
526 return ret;
527 p -= newsize; len -= newsize;
528
529 break;
530 }
531 case A1_OP_SETOF: {
532 const struct template_of *el = DPOC(data, t->offset);
533 size_t ellen = sizeofType(t->ptr);
534 struct heim_octet_string *val;
535 unsigned char *elptr = el->val;
536 size_t i, totallen;
537
538 if (el->len == 0)
539 break;
540
541 if (el->len > UINT_MAX/sizeof(val[0]))
542 return ERANGE;
543
544 val = malloc(sizeof(val[0]) * el->len);
545 if (val == NULL)
546 return ENOMEM;
547
548 for(totallen = 0, i = 0; i < el->len; i++) {
549 unsigned char *next;
550 size_t l;
551
552 val[i].length = _asn1_length(t->ptr, elptr);
553 val[i].data = malloc(val[i].length);
554
555 ret = _asn1_encode(t->ptr, DPO(val[i].data, val[i].length - 1),
556 val[i].length, elptr, &l);
557 if (ret)
558 break;
559
560 next = elptr + ellen;
561 if (next < elptr) {
562 ret = ASN1_OVERFLOW;
563 break;
564 }
565 elptr = next;
566 totallen += val[i].length;
567 }
568 if (ret == 0 && totallen > len)
569 ret = ASN1_OVERFLOW;
570 if (ret) {
571 do {
572 free(val[i].data);
573 } while(i-- > 0);
574 free(val);
575 return ret;
576 }
577
578 len -= totallen;
579
580 qsort(val, el->len, sizeof(val[0]), _heim_der_set_sort);
581
582 i = el->len - 1;
583 do {
584 p -= val[i].length;
585 memcpy(p + 1, val[i].data, val[i].length);
586 free(val[i].data);
587 } while(i-- > 0);
588 free(val);
589
590 break;
591
592 }
593 case A1_OP_SEQOF: {
594 struct template_of *el = DPO(data, t->offset);
595 size_t ellen = sizeofType(t->ptr);
596 size_t newsize;
597 unsigned int i;
598 unsigned char *elptr = el->val;
599
600 if (el->len == 0)
601 break;
602
603 elptr += ellen * (el->len - 1);
604
605 for (i = 0; i < el->len; i++) {
606 ret = _asn1_encode(t->ptr, p, len,
607 elptr,
608 &newsize);
609 if (ret)
610 return ret;
611 p -= newsize; len -= newsize;
612 elptr -= ellen;
613 }
614
615 break;
616 }
617 case A1_OP_BMEMBER: {
618 const struct asn1_template *bmember = t->ptr;
619 size_t size = bmember->offset;
620 size_t els = A1_HEADER_LEN(bmember);
621 size_t pos;
622 unsigned char c = 0;
623 unsigned int bitset = 0;
624 int rfc1510 = (bmember->tt & A1_HBF_RFC1510);
625
626 bmember += els;
627
628 if (rfc1510)
629 pos = 31;
630 else
631 pos = bmember->offset;
632
633 while (els && len) {
634 while (bmember->offset / 8 < pos / 8) {
635 if (rfc1510 || bitset || c) {
636 if (len < 1)
637 return ASN1_OVERFLOW;
638 *p-- = c; len--;
639 }
640 c = 0;
641 pos -= 8;
642 }
643 bmember_put_bit(&c, data, bmember->offset, size, &bitset);
644 els--; bmember--;
645 }
646 if (rfc1510 || bitset) {
647 if (len < 1)
648 return ASN1_OVERFLOW;
649 *p-- = c; len--;
650 }
651
652 if (len < 1)
653 return ASN1_OVERFLOW;
654 if (rfc1510 || bitset == 0)
655 *p-- = 0;
656 else
657 *p-- = bitset - 1;
658
659 len--;
660
661 break;
662 }
663 case A1_OP_CHOICE: {
664 const struct asn1_template *choice = t->ptr;
665 const unsigned int *element = DPOC(data, choice->offset);
666 size_t datalen;
667 const void *el;
668
669 if (*element > A1_HEADER_LEN(choice)) {
670 printf("element: %d\n", *element);
671 return ASN1_PARSE_ERROR;
672 }
673
674 if (*element == 0) {
675 ret += der_put_octet_string(p, len,
676 DPOC(data, choice->tt), &datalen);
677 } else {
678 choice += *element;
679 el = DPOC(data, choice->offset);
680 ret = _asn1_encode(choice->ptr, p, len, el, &datalen);
681 if (ret)
682 return ret;
683 }
684 len -= datalen; p -= datalen;
685
686 break;
687 }
688 default:
689 ABORT_ON_ERROR();
690 }
691 t--;
692 elements--;
693 }
694 if (retsize)
695 *retsize = oldlen - len;
696
697 return 0;
698 }
699
700 size_t
701 _asn1_length(const struct asn1_template *t, const void *data)
702 {
703 size_t elements = A1_HEADER_LEN(t);
704 size_t ret = 0;
705
706 t += A1_HEADER_LEN(t);
707
708 while (elements) {
709 switch (t->tt & A1_OP_MASK) {
710 case A1_OP_TYPE:
711 case A1_OP_TYPE_EXTERN: {
712 const void *el = DPOC(data, t->offset);
713
714 if (t->tt & A1_FLAG_OPTIONAL) {
715 void **pel = (void **)el;
716 if (*pel == NULL)
717 break;
718 el = *pel;
719 }
720
721 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
722 ret += _asn1_length(t->ptr, el);
723 } else {
724 const struct asn1_type_func *f = t->ptr;
725 ret += (f->length)(el);
726 }
727 break;
728 }
729 case A1_OP_TAG: {
730 size_t datalen;
731 const void *olddata = data;
732
733 data = DPO(data, t->offset);
734
735 if (t->tt & A1_FLAG_OPTIONAL) {
736 void **el = (void **)data;
737 if (*el == NULL) {
738 data = olddata;
739 break;
740 }
741 data = *el;
742 }
743 datalen = _asn1_length(t->ptr, data);
744 ret += der_length_tag(A1_TAG_TAG(t->tt)) + der_length_len(datalen);
745 ret += datalen;
746 data = olddata;
747 break;
748 }
749 case A1_OP_PARSE: {
750 unsigned int type = A1_PARSE_TYPE(t->tt);
751 const void *el = DPOC(data, t->offset);
752
753 if (type > sizeof(prim)/sizeof(prim[0])) {
754 ABORT_ON_ERROR();
755 break;
756 }
757 ret += (prim[type].length)(el);
758 break;
759 }
760 case A1_OP_SETOF:
761 case A1_OP_SEQOF: {
762 const struct template_of *el = DPOC(data, t->offset);
763 size_t ellen = sizeofType(t->ptr);
764 const unsigned char *element = el->val;
765 unsigned int i;
766
767 for (i = 0; i < el->len; i++) {
768 ret += _asn1_length(t->ptr, element);
769 element += ellen;
770 }
771
772 break;
773 }
774 case A1_OP_BMEMBER: {
775 const struct asn1_template *bmember = t->ptr;
776 size_t size = bmember->offset;
777 size_t els = A1_HEADER_LEN(bmember);
778 int rfc1510 = (bmember->tt & A1_HBF_RFC1510);
779
780 if (rfc1510) {
781 ret += 5;
782 } else {
783
784 ret += 1;
785
786 bmember += els;
787
788 while (els) {
789 if (bmember_isset_bit(data, bmember->offset, size)) {
790 ret += (bmember->offset / 8) + 1;
791 break;
792 }
793 els--; bmember--;
794 }
795 }
796 break;
797 }
798 case A1_OP_CHOICE: {
799 const struct asn1_template *choice = t->ptr;
800 const unsigned int *element = DPOC(data, choice->offset);
801
802 if (*element > A1_HEADER_LEN(choice))
803 break;
804
805 if (*element == 0) {
806 ret += der_length_octet_string(DPOC(data, choice->tt));
807 } else {
808 choice += *element;
809 ret += _asn1_length(choice->ptr, DPOC(data, choice->offset));
810 }
811 break;
812 }
813 default:
814 ABORT_ON_ERROR();
815 break;
816 }
817 elements--;
818 t--;
819 }
820 return ret;
821 }
822
823 void
824 _asn1_free(const struct asn1_template *t, void *data)
825 {
826 size_t elements = A1_HEADER_LEN(t);
827
828 if (t->tt & A1_HF_PRESERVE)
829 der_free_octet_string(data);
830
831 t++;
832
833 while (elements) {
834 switch (t->tt & A1_OP_MASK) {
835 case A1_OP_TYPE:
836 case A1_OP_TYPE_EXTERN: {
837 void *el = DPO(data, t->offset);
838
839 if (t->tt & A1_FLAG_OPTIONAL) {
840 void **pel = (void **)el;
841 if (*pel == NULL)
842 break;
843 el = *pel;
844 }
845
846 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
847 _asn1_free(t->ptr, el);
848 } else {
849 const struct asn1_type_func *f = t->ptr;
850 (f->release)(el);
851 }
852 if (t->tt & A1_FLAG_OPTIONAL)
853 free(el);
854
855 break;
856 }
857 case A1_OP_PARSE: {
858 unsigned int type = A1_PARSE_TYPE(t->tt);
859 void *el = DPO(data, t->offset);
860
861 if (type > sizeof(prim)/sizeof(prim[0])) {
862 ABORT_ON_ERROR();
863 break;
864 }
865 (prim[type].release)(el);
866 break;
867 }
868 case A1_OP_TAG: {
869 void *el = DPO(data, t->offset);
870
871 if (t->tt & A1_FLAG_OPTIONAL) {
872 void **pel = (void **)el;
873 if (*pel == NULL)
874 break;
875 el = *pel;
876 }
877
878 _asn1_free(t->ptr, el);
879
880 if (t->tt & A1_FLAG_OPTIONAL)
881 free(el);
882
883 break;
884 }
885 case A1_OP_SETOF:
886 case A1_OP_SEQOF: {
887 struct template_of *el = DPO(data, t->offset);
888 size_t ellen = sizeofType(t->ptr);
889 unsigned char *element = el->val;
890 unsigned int i;
891
892 for (i = 0; i < el->len; i++) {
893 _asn1_free(t->ptr, element);
894 element += ellen;
895 }
896 free(el->val);
897 el->val = NULL;
898 el->len = 0;
899
900 break;
901 }
902 case A1_OP_BMEMBER:
903 break;
904 case A1_OP_CHOICE: {
905 const struct asn1_template *choice = t->ptr;
906 const unsigned int *element = DPOC(data, choice->offset);
907
908 if (*element > A1_HEADER_LEN(choice))
909 break;
910
911 if (*element == 0) {
912 der_free_octet_string(DPO(data, choice->tt));
913 } else {
914 choice += *element;
915 _asn1_free(choice->ptr, DPO(data, choice->offset));
916 }
917 break;
918 }
919 default:
920 ABORT_ON_ERROR();
921 break;
922 }
923 t++;
924 elements--;
925 }
926 }
927
928 int
929 _asn1_copy(const struct asn1_template *t, const void *from, void *to)
930 {
931 size_t elements = A1_HEADER_LEN(t);
932 int ret = 0;
933 int preserve = (t->tt & A1_HF_PRESERVE);
934
935 t++;
936
937 if (preserve) {
938 ret = der_copy_octet_string(from, to);
939 if (ret)
940 return ret;
941 }
942
943 while (elements) {
944 switch (t->tt & A1_OP_MASK) {
945 case A1_OP_TYPE:
946 case A1_OP_TYPE_EXTERN: {
947 const void *fel = DPOC(from, t->offset);
948 void *tel = DPO(to, t->offset);
949 void **ptel = (void **)tel;
950 size_t size;
951
952 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
953 size = sizeofType(t->ptr);
954 } else {
955 const struct asn1_type_func *f = t->ptr;
956 size = f->size;
957 }
958
959 if (t->tt & A1_FLAG_OPTIONAL) {
960 void **pfel = (void **)fel;
961 if (*pfel == NULL)
962 break;
963 fel = *pfel;
964
965 tel = *ptel = calloc(1, size);
966 if (tel == NULL)
967 return ENOMEM;
968 }
969
970 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
971 ret = _asn1_copy(t->ptr, fel, tel);
972 } else {
973 const struct asn1_type_func *f = t->ptr;
974 ret = (f->copy)(fel, tel);
975 }
976
977 if (ret) {
978 if (t->tt & A1_FLAG_OPTIONAL) {
979 free(*ptel);
980 *ptel = NULL;
981 }
982 return ret;
983 }
984 break;
985 }
986 case A1_OP_PARSE: {
987 unsigned int type = A1_PARSE_TYPE(t->tt);
988 const void *fel = DPOC(from, t->offset);
989 void *tel = DPO(to, t->offset);
990
991 if (type > sizeof(prim)/sizeof(prim[0])) {
992 ABORT_ON_ERROR();
993 return ASN1_PARSE_ERROR;
994 }
995 ret = (prim[type].copy)(fel, tel);
996 if (ret)
997 return ret;
998 break;
999 }
1000 case A1_OP_TAG: {
1001 const void *oldfrom = from;
1002 void *oldto = to;
1003 void **tel = NULL;
1004
1005 from = DPOC(from, t->offset);
1006 to = DPO(to, t->offset);
1007
1008 if (t->tt & A1_FLAG_OPTIONAL) {
1009 void **fel = (void **)from;
1010 tel = (void **)to;
1011 if (*fel == NULL) {
1012 from = oldfrom;
1013 to = oldto;
1014 break;
1015 }
1016 from = *fel;
1017
1018 to = *tel = calloc(1, sizeofType(t->ptr));
1019 if (to == NULL)
1020 return ENOMEM;
1021 }
1022
1023 ret = _asn1_copy(t->ptr, from, to);
1024 if (ret) {
1025 if (t->tt & A1_FLAG_OPTIONAL) {
1026 free(*tel);
1027 *tel = NULL;
1028 }
1029 return ret;
1030 }
1031
1032 from = oldfrom;
1033 to = oldto;
1034
1035 break;
1036 }
1037 case A1_OP_SETOF:
1038 case A1_OP_SEQOF: {
1039 const struct template_of *fel = DPOC(from, t->offset);
1040 struct template_of *tel = DPO(to, t->offset);
1041 size_t ellen = sizeofType(t->ptr);
1042 unsigned int i;
1043
1044 tel->val = calloc(fel->len, ellen);
1045 if (tel->val == NULL)
1046 return ENOMEM;
1047
1048 tel->len = fel->len;
1049
1050 for (i = 0; i < fel->len; i++) {
1051 ret = _asn1_copy(t->ptr,
1052 DPOC(fel->val, (i * ellen)),
1053 DPO(tel->val, (i *ellen)));
1054 if (ret)
1055 return ret;
1056 }
1057 break;
1058 }
1059 case A1_OP_BMEMBER: {
1060 const struct asn1_template *bmember = t->ptr;
1061 size_t size = bmember->offset;
1062 memcpy(to, from, size);
1063 break;
1064 }
1065 case A1_OP_CHOICE: {
1066 const struct asn1_template *choice = t->ptr;
1067 const unsigned int *felement = DPOC(from, choice->offset);
1068 unsigned int *telement = DPO(to, choice->offset);
1069
1070 if (*felement > A1_HEADER_LEN(choice))
1071 return ASN1_PARSE_ERROR;
1072
1073 *telement = *felement;
1074
1075 if (*felement == 0) {
1076 ret = der_copy_octet_string(DPOC(from, choice->tt), DPO(to, choice->tt));
1077 } else {
1078 choice += *felement;
1079 ret = _asn1_copy(choice->ptr,
1080 DPOC(from, choice->offset),
1081 DPO(to, choice->offset));
1082 }
1083 if (ret)
1084 return ret;
1085 break;
1086 }
1087 default:
1088 ABORT_ON_ERROR();
1089 break;
1090 }
1091 t++;
1092 elements--;
1093 }
1094 return 0;
1095 }
1096
1097 int
1098 _asn1_decode_top(const struct asn1_template *t, unsigned flags, const unsigned char *p, size_t len, void *data, size_t *size)
1099 {
1100 int ret;
1101 memset(data, 0, t->offset);
1102 ret = _asn1_decode(t, flags, p, len, data, size);
1103 if (ret) {
1104 _asn1_free(t, data);
1105 memset(data, 0, t->offset);
1106 }
1107
1108 return ret;
1109 }
1110
1111 int
1112 _asn1_copy_top(const struct asn1_template *t, const void *from, void *to)
1113 {
1114 int ret;
1115 memset(to, 0, t->offset);
1116 ret = _asn1_copy(t, from, to);
1117 if (ret) {
1118 _asn1_free(t, to);
1119 memset(to, 0, t->offset);
1120 }
1121 return ret;
1122 }
Heimdal