Debian Codegraph @

lib/asn1/fuzzer.c

raw
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 - 2010 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 enum trigger_method { FOFF, FRANDOM, FLINEAR, FLINEAR_SIZE };
40
41 #ifdef ASN1_FUZZER
42 static enum trigger_method method = FOFF;
43
44 /* FLINEAR */
45 static unsigned long fnum, fcur, fsize;
46 #endif
47
48 int
49 asn1_fuzzer_method(const char *mode)
50 {
51 #ifdef ASN1_FUZZER
52 if (mode == NULL || strcasecmp(mode, "off") == 0) {
53 method = FOFF;
54 } else if (strcasecmp(mode, "random") == 0) {
55 method = FRANDOM;
56 } else if (strcasecmp(mode, "linear") == 0) {
57 method = FLINEAR;
58 } else if (strcasecmp(mode, "linear-size") == 0) {
59 method = FLINEAR_SIZE;
60 } else
61 return 1;
62 return 0;
63 #else
64 return 1;
65 #endif
66 }
67
68 void
69 asn1_fuzzer_reset(void)
70 {
71 #ifdef ASN1_FUZZER
72 fcur = 0;
73 fsize = 0;
74 fnum = 0;
75 #endif
76 }
77
78 void
79 asn1_fuzzer_next(void)
80 {
81 #ifdef ASN1_FUZZER
82 fcur = 0;
83 fsize = 0;
84 fnum++;
85 #endif
86 }
87
88 int
89 asn1_fuzzer_done(void)
90 {
91 #ifndef ASN1_FUZZER
92 abort();
93 #else
94 /* since code paths */
95 return (fnum > 10000);
96 #endif
97 }
98
99 #ifdef ASN1_FUZZER
100
101 static int
102 fuzzer_trigger(unsigned int chance)
103 {
104 switch(method) {
105 case FOFF:
106 return 0;
107 case FRANDOM:
108 if ((rk_random() % chance) != 1)
109 return 0;
110 return 1;
111 case FLINEAR:
112 if (fnum == fcur++)
113 return 1;
114 return 0;
115 case FLINEAR_SIZE:
116 return 0;
117 }
118 return 0;
119 }
120
121 static int
122 fuzzer_size_trigger(unsigned long *cur)
123 {
124 if (method != FLINEAR_SIZE)
125 return 0;
126 if (fnum == (*cur)++)
127 return 1;
128 return 0;
129 }
130
131 static size_t
132 fuzzer_length_len (size_t len)
133 {
134 if (fuzzer_size_trigger(&fsize)) {
135 len = 0;
136 } else if (fuzzer_size_trigger(&fsize)) {
137 len = 129;
138 } else if (fuzzer_size_trigger(&fsize)) {
139 len = 0xffff;
140 }
141
142 if (len < 128)
143 return 1;
144 else {
145 int ret = 0;
146 do {
147 ++ret;
148 len /= 256;
149 } while (len);
150 return ret + 1;
151 }
152 }
153
154 static int
155 fuzzer_put_length (unsigned char *p, size_t len, size_t val, size_t *size)
156 {
157 if (len < 1)
158 return ASN1_OVERFLOW;
159
160 if (fuzzer_size_trigger(&fcur)) {
161 val = 0;
162 } else if (fuzzer_size_trigger(&fcur)) {
163 val = 129;
164 } else if (fuzzer_size_trigger(&fcur)) {
165 val = 0xffff;
166 }
167
168 if (val < 128) {
169 *p = val;
170 *size = 1;
171 } else {
172 size_t l = 0;
173
174 while(val > 0) {
175 if(len < 2)
176 return ASN1_OVERFLOW;
177 *p-- = val % 256;
178 val /= 256;
179 len--;
180 l++;
181 }
182 *p = 0x80 | l;
183 if(size)
184 *size = l + 1;
185 }
186 return 0;
187 }
188
189 static int
190 fuzzer_put_tag (unsigned char *p, size_t len, Der_class class, Der_type type,
191 unsigned int tag, size_t *size)
192 {
193 unsigned fcont = 0;
194
195 if (tag <= 30) {
196 if (len < 1)
197 return ASN1_OVERFLOW;
198 if (fuzzer_trigger(100))
199 *p = MAKE_TAG(class, type, 0x1f);
200 else
201 *p = MAKE_TAG(class, type, tag);
202 *size = 1;
203 } else {
204 size_t ret = 0;
205 unsigned int continuation = 0;
206
207 do {
208 if (len < 1)
209 return ASN1_OVERFLOW;
210 *p-- = tag % 128 | continuation;
211 len--;
212 ret++;
213 tag /= 128;
214 continuation = 0x80;
215 } while(tag > 0);
216 if (len < 1)
217 return ASN1_OVERFLOW;
218 if (fuzzer_trigger(100))
219 *p-- = MAKE_TAG(class, type, 0);
220 else
221 *p-- = MAKE_TAG(class, type, 0x1f);
222 ret++;
223 *size = ret;
224 }
225 return 0;
226 }
227
228 static int
229 fuzzer_put_length_and_tag (unsigned char *p, size_t len, size_t len_val,
230 Der_class class, Der_type type,
231 unsigned int tag, size_t *size)
232 {
233 size_t ret = 0;
234 size_t l;
235 int e;
236
237 e = fuzzer_put_length (p, len, len_val, &l);
238 if(e)
239 return e;
240 p -= l;
241 len -= l;
242 ret += l;
243 e = fuzzer_put_tag (p, len, class, type, tag, &l);
244 if(e)
245 return e;
246
247 ret += l;
248 *size = ret;
249 return 0;
250 }
251
252 static int
253 fuzzer_put_general_string (unsigned char *p, size_t len,
254 const heim_general_string *str, size_t *size)
255 {
256 size_t slen = strlen(*str);
257
258 if (len < slen)
259 return ASN1_OVERFLOW;
260 p -= slen;
261 if (slen >= 2 && fuzzer_trigger(100)) {
262 memcpy(p+1, *str, slen);
263 memcpy(p+1, "%s", 2);
264 } else if (slen >= 2 && fuzzer_trigger(100)) {
265 memcpy(p+1, *str, slen);
266 memcpy(p+1, "%n", 2);
267 } else if (slen >= 4 && fuzzer_trigger(100)) {
268 memcpy(p+1, *str, slen);
269 memcpy(p+1, "%10n", 4);
270 } else if (slen >= 10 && fuzzer_trigger(100)) {
271 memcpy(p+1, *str, slen);
272 memcpy(p+1, "%n%n%n%n%n", 10);
273 } else if (slen >= 10 && fuzzer_trigger(100)) {
274 memcpy(p+1, *str, slen);
275 memcpy(p+1, "%n%p%s%d%x", 10);
276 } else if (slen >= 7 && fuzzer_trigger(100)) {
277 memcpy(p+1, *str, slen);
278 memcpy(p+1, "%.1024d", 7);
279 } else if (slen >= 7 && fuzzer_trigger(100)) {
280 memcpy(p+1, *str, slen);
281 memcpy(p+1, "%.2049d", 7);
282 } else if (fuzzer_trigger(100)) {
283 memset(p+1, 0, slen);
284 } else if (fuzzer_trigger(100)) {
285 memset(p+1, 0xff, slen);
286 } else if (fuzzer_trigger(100)) {
287 memset(p+1, 'A', slen);
288 } else {
289 memcpy(p+1, *str, slen);
290 }
291 *size = slen;
292 return 0;
293 }
294
295
296 struct asn1_type_func fuzzerprim[A1T_NUM_ENTRY] = {
297 #define fuzel(name, type) { \
298 (asn1_type_encode)fuzzer_put_##name, \
299 (asn1_type_decode)der_get_##name, \
300 (asn1_type_length)der_length_##name, \
301 (asn1_type_copy)der_copy_##name, \
302 (asn1_type_release)der_free_##name, \
303 sizeof(type) \
304 }
305 #define el(name, type) { \
306 (asn1_type_encode)der_put_##name, \
307 (asn1_type_decode)der_get_##name, \
308 (asn1_type_length)der_length_##name, \
309 (asn1_type_copy)der_copy_##name, \
310 (asn1_type_release)der_free_##name, \
311 sizeof(type) \
312 }
313 #define elber(name, type) { \
314 (asn1_type_encode)der_put_##name, \
315 (asn1_type_decode)der_get_##name##_ber, \
316 (asn1_type_length)der_length_##name, \
317 (asn1_type_copy)der_copy_##name, \
318 (asn1_type_release)der_free_##name, \
319 sizeof(type) \
320 }
321 el(integer, int),
322 el(integer64, int64_t),
323 el(heim_integer, heim_integer),
324 el(integer, int),
325 el(unsigned, unsigned),
326 el(uninteger64, uint64_t),
327 fuzel(general_string, heim_general_string),
328 el(octet_string, heim_octet_string),
329 elber(octet_string, heim_octet_string),
330 el(ia5_string, heim_ia5_string),
331 el(bmp_string, heim_bmp_string),
332 el(universal_string, heim_universal_string),
333 el(printable_string, heim_printable_string),
334 el(visible_string, heim_visible_string),
335 el(utf8string, heim_utf8_string),
336 el(generalized_time, time_t),
337 el(utctime, time_t),
338 el(bit_string, heim_bit_string),
339 { (asn1_type_encode)der_put_boolean, (asn1_type_decode)der_get_boolean,
340 (asn1_type_length)der_length_boolean, (asn1_type_copy)der_copy_integer,
341 (asn1_type_release)der_free_integer, sizeof(int)
342 },
343 el(oid, heim_oid),
344 el(general_string, heim_general_string),
345 #undef fuzel
346 #undef el
347 #undef elber
348 };
349
350
351
352 int
353 _asn1_encode_fuzzer(const struct asn1_template *t,
354 unsigned char *p, size_t len,
355 const void *data, size_t *size)
356 {
357 size_t elements = A1_HEADER_LEN(t);
358 int ret = 0;
359 size_t oldlen = len;
360
361 t += A1_HEADER_LEN(t);
362
363 while (elements) {
364 switch (t->tt & A1_OP_MASK) {
365 case A1_OP_TYPE:
366 case A1_OP_TYPE_EXTERN: {
367 size_t newsize;
368 const void *el = DPOC(data, t->offset);
369
370 if (t->tt & A1_FLAG_OPTIONAL) {
371 void **pel = (void **)el;
372 if (*pel == NULL)
373 break;
374 el = *pel;
375 }
376
377 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
378 ret = _asn1_encode_fuzzer(t->ptr, p, len, el, &newsize);
379 } else {
380 const struct asn1_type_func *f = t->ptr;
381 ret = (f->encode)(p, len, el, &newsize);
382 }
383
384 if (ret)
385 return ret;
386 p -= newsize; len -= newsize;
387
388 break;
389 }
390 case A1_OP_TAG: {
391 const void *olddata = data;
392 size_t l, datalen;
393
394 data = DPOC(data, t->offset);
395
396 if (t->tt & A1_FLAG_OPTIONAL) {
397 void **el = (void **)data;
398 if (*el == NULL) {
399 data = olddata;
400 break;
401 }
402 data = *el;
403 }
404
405 ret = _asn1_encode_fuzzer(t->ptr, p, len, data, &datalen);
406 if (ret)
407 return ret;
408
409 len -= datalen; p -= datalen;
410
411 ret = fuzzer_put_length_and_tag(p, len, datalen,
412 A1_TAG_CLASS(t->tt),
413 A1_TAG_TYPE(t->tt),
414 A1_TAG_TAG(t->tt), &l);
415 if (ret)
416 return ret;
417
418 p -= l; len -= l;
419
420 data = olddata;
421
422 break;
423 }
424 case A1_OP_PARSE: {
425 unsigned int type = A1_PARSE_TYPE(t->tt);
426 size_t newsize;
427 const void *el = DPOC(data, t->offset);
428
429 if (type > sizeof(fuzzerprim)/sizeof(fuzzerprim[0])) {
430 ABORT_ON_ERROR();
431 return ASN1_PARSE_ERROR;
432 }
433
434 ret = (fuzzerprim[type].encode)(p, len, el, &newsize);
435 if (ret)
436 return ret;
437 p -= newsize; len -= newsize;
438
439 break;
440 }
441 case A1_OP_SETOF: {
442 const struct template_of *el = DPOC(data, t->offset);
443 size_t ellen = _asn1_sizeofType(t->ptr);
444 heim_octet_string *val;
445 unsigned char *elptr = el->val;
446 size_t i, totallen;
447
448 if (el->len == 0)
449 break;
450
451 if (el->len > UINT_MAX/sizeof(val[0]))
452 return ERANGE;
453
454 val = malloc(sizeof(val[0]) * el->len);
455 if (val == NULL)
456 return ENOMEM;
457
458 for(totallen = 0, i = 0; i < el->len; i++) {
459 unsigned char *next;
460 size_t l;
461
462 val[i].length = _asn1_length(t->ptr, elptr);
463 val[i].data = malloc(val[i].length);
464
465 ret = _asn1_encode_fuzzer(t->ptr, DPO(val[i].data, val[i].length - 1),
466 val[i].length, elptr, &l);
467 if (ret)
468 break;
469
470 next = elptr + ellen;
471 if (next < elptr) {
472 ret = ASN1_OVERFLOW;
473 break;
474 }
475 elptr = next;
476 totallen += val[i].length;
477 }
478 if (ret == 0 && totallen > len)
479 ret = ASN1_OVERFLOW;
480 if (ret) {
481 do {
482 free(val[i].data);
483 } while(i-- > 0);
484 free(val);
485 return ret;
486 }
487
488 len -= totallen;
489
490 qsort(val, el->len, sizeof(val[0]), _heim_der_set_sort);
491
492 i = el->len - 1;
493 do {
494 p -= val[i].length;
495 memcpy(p + 1, val[i].data, val[i].length);
496 free(val[i].data);
497 } while(i-- > 0);
498 free(val);
499
500 break;
501
502 }
503 case A1_OP_SEQOF: {
504 struct template_of *el = DPO(data, t->offset);
505 size_t ellen = _asn1_sizeofType(t->ptr);
506 size_t newsize;
507 unsigned int i;
508 unsigned char *elptr = el->val;
509
510 if (el->len == 0)
511 break;
512
513 elptr += ellen * (el->len - 1);
514
515 for (i = 0; i < el->len; i++) {
516 ret = _asn1_encode_fuzzer(t->ptr, p, len,
517 elptr,
518 &newsize);
519 if (ret)
520 return ret;
521 p -= newsize; len -= newsize;
522 elptr -= ellen;
523 }
524
525 break;
526 }
527 case A1_OP_BMEMBER: {
528 const struct asn1_template *bmember = t->ptr;
529 size_t size = bmember->offset;
530 size_t elements = A1_HEADER_LEN(bmember);
531 size_t pos;
532 unsigned char c = 0;
533 unsigned int bitset = 0;
534 int rfc1510 = (bmember->tt & A1_HBF_RFC1510);
535
536 bmember += elements;
537
538 if (rfc1510)
539 pos = 31;
540 else
541 pos = bmember->offset;
542
543 while (elements && len) {
544 while (bmember->offset / 8 < pos / 8) {
545 if (rfc1510 || bitset || c) {
546 if (len < 1)
547 return ASN1_OVERFLOW;
548 *p-- = c; len--;
549 }
550 c = 0;
551 pos -= 8;
552 }
553 _asn1_bmember_put_bit(&c, data, bmember->offset, size, &bitset);
554 elements--; bmember--;
555 }
556 if (rfc1510 || bitset) {
557 if (len < 1)
558 return ASN1_OVERFLOW;
559 *p-- = c; len--;
560 }
561
562 if (len < 1)
563 return ASN1_OVERFLOW;
564 if (rfc1510 || bitset == 0)
565 *p-- = 0;
566 else
567 *p-- = bitset - 1;
568
569 len--;
570
571 break;
572 }
573 case A1_OP_CHOICE: {
574 const struct asn1_template *choice = t->ptr;
575 const unsigned int *element = DPOC(data, choice->offset);
576 size_t datalen;
577 const void *el;
578
579 if (*element > A1_HEADER_LEN(choice)) {
580 printf("element: %d\n", *element);
581 return ASN1_PARSE_ERROR;
582 }
583
584 if (*element == 0) {
585 ret += der_put_octet_string(p, len,
586 DPOC(data, choice->tt), &datalen);
587 } else {
588 choice += *element;
589 el = DPOC(data, choice->offset);
590 ret = _asn1_encode_fuzzer(choice->ptr, p, len, el, &datalen);
591 if (ret)
592 return ret;
593 }
594 len -= datalen; p -= datalen;
595
596 break;
597 }
598 default:
599 ABORT_ON_ERROR();
600 }
601 t--;
602 elements--;
603 }
604
605 if (fuzzer_trigger(1000)) {
606 memset(p + 1, 0, oldlen - len);
607 } else if (fuzzer_trigger(1000)) {
608 memset(p + 1, 0x41, oldlen - len);
609 } else if (fuzzer_trigger(1000)) {
610 memset(p + 1, 0xff, oldlen - len);
611 }
612
613 if (size)
614 *size = oldlen - len;
615
616 return 0;
617 }
618
619 size_t
620 _asn1_length_fuzzer(const struct asn1_template *t, const void *data)
621 {
622 size_t elements = A1_HEADER_LEN(t);
623 size_t ret = 0;
624
625 t += A1_HEADER_LEN(t);
626
627 while (elements) {
628 switch (t->tt & A1_OP_MASK) {
629 case A1_OP_TYPE:
630 case A1_OP_TYPE_EXTERN: {
631 const void *el = DPOC(data, t->offset);
632
633 if (t->tt & A1_FLAG_OPTIONAL) {
634 void **pel = (void **)el;
635 if (*pel == NULL)
636 break;
637 el = *pel;
638 }
639
640 if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
641 ret += _asn1_length(t->ptr, el);
642 } else {
643 const struct asn1_type_func *f = t->ptr;
644 ret += (f->length)(el);
645 }
646 break;
647 }
648 case A1_OP_TAG: {
649 size_t datalen;
650 const void *olddata = data;
651
652 data = DPO(data, t->offset);
653
654 if (t->tt & A1_FLAG_OPTIONAL) {
655 void **el = (void **)data;
656 if (*el == NULL) {
657 data = olddata;
658 break;
659 }
660 data = *el;
661 }
662 datalen = _asn1_length(t->ptr, data);
663 ret += der_length_tag(A1_TAG_TAG(t->tt)) + fuzzer_length_len(datalen);
664 ret += datalen;
665 data = olddata;
666 break;
667 }
668 case A1_OP_PARSE: {
669 unsigned int type = A1_PARSE_TYPE(t->tt);
670 const void *el = DPOC(data, t->offset);
671
672 if (type >= sizeof(asn1_template_prim)/sizeof(asn1_template_prim[0])) {
673 ABORT_ON_ERROR();
674 break;
675 }
676 ret += (asn1_template_prim[type].length)(el);
677 break;
678 }
679 case A1_OP_SETOF:
680 case A1_OP_SEQOF: {
681 const struct template_of *el = DPOC(data, t->offset);
682 size_t ellen = _asn1_sizeofType(t->ptr);
683 const unsigned char *element = el->val;
684 unsigned int i;
685
686 for (i = 0; i < el->len; i++) {
687 ret += _asn1_length(t->ptr, element);
688 element += ellen;
689 }
690
691 break;
692 }
693 case A1_OP_BMEMBER: {
694 const struct asn1_template *bmember = t->ptr;
695 size_t size = bmember->offset;
696 size_t elements = A1_HEADER_LEN(bmember);
697 int rfc1510 = (bmember->tt & A1_HBF_RFC1510);
698
699 if (rfc1510) {
700 ret += 5;
701 } else {
702
703 ret += 1;
704
705 bmember += elements;
706
707 while (elements) {
708 if (_asn1_bmember_isset_bit(data, bmember->offset, size)) {
709 ret += (bmember->offset / 8) + 1;
710 break;
711 }
712 elements--; bmember--;
713 }
714 }
715 break;
716 }
717 case A1_OP_CHOICE: {
718 const struct asn1_template *choice = t->ptr;
719 const unsigned int *element = DPOC(data, choice->offset);
720
721 if (*element > A1_HEADER_LEN(choice))
722 break;
723
724 if (*element == 0) {
725 ret += der_length_octet_string(DPOC(data, choice->tt));
726 } else {
727 choice += *element;
728 ret += _asn1_length(choice->ptr, DPOC(data, choice->offset));
729 }
730 break;
731 }
732 default:
733 ABORT_ON_ERROR();
734 break;
735 }
736 elements--;
737 t--;
738 }
739 return ret;
740 }
741
742 #endif /* ASN1_FUZZER */