?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Spelling
[heimdal.git] / lib / asn1 / check-der.c
blob5c46c7cc2940185ae38ede36d9e722834549df91
1 /*
2 * Copyright (c) 1999 - 2007 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #include "der_locl.h"
35 #include <err.h>
36 #include <roken.h>
37
38 #include <asn1-common.h>
39 #include <asn1_err.h>
40 #include <der.h>
41
42 #include "check-common.h"
43
44 RCSID("$Id$");
45
46 static int
47 cmp_integer (void *a, void *b)
48 {
49 int *ia = (int *)a;
50 int *ib = (int *)b;
51
52 return *ib - *ia;
53 }
54
55 static int
56 test_integer (void)
57 {
58 struct test_case tests[] = {
59 {NULL, 1, "\x00"},
60 {NULL, 1, "\x7f"},
61 {NULL, 2, "\x00\x80"},
62 {NULL, 2, "\x01\x00"},
63 {NULL, 1, "\x80"},
64 {NULL, 2, "\xff\x7f"},
65 {NULL, 1, "\xff"},
66 {NULL, 2, "\xff\x01"},
67 {NULL, 2, "\x00\xff"},
68 {NULL, 4, "\x7f\xff\xff\xff"}
69 };
70
71 int values[] = {0, 127, 128, 256, -128, -129, -1, -255, 255,
72 0x7fffffff};
73 int i, ret;
74 int ntests = sizeof(tests) / sizeof(*tests);
75
76 for (i = 0; i < ntests; ++i) {
77 tests[i].val = &values[i];
78 asprintf (&tests[i].name, "integer %d", values[i]);
79 if (tests[i].name == NULL)
80 errx(1, "malloc");
81 }
82
83 ret = generic_test (tests, ntests, sizeof(int),
84 (generic_encode)der_put_integer,
85 (generic_length) der_length_integer,
86 (generic_decode)der_get_integer,
87 (generic_free)NULL,
88 cmp_integer);
89
90 for (i = 0; i < ntests; ++i)
91 free (tests[i].name);
92 return ret;
93 }
94
95 static int
96 test_one_int(int val)
97 {
98 int ret, dval;
99 unsigned char *buf;
100 size_t len_len, len;
101
102 len = _heim_len_int(val);
103
104 buf = emalloc(len + 2);
105
106 buf[0] = '\xff';
107 buf[len + 1] = '\xff';
108 memset(buf + 1, 0, len);
109
110 ret = der_put_integer(buf + 1 + len - 1, len, &val, &len_len);
111 if (ret) {
112 printf("integer %d encode failed %d\n", val, ret);
113 return 1;
114 }
115 if (len != len_len) {
116 printf("integer %d encode fail with %d len %lu, result len %lu\n",
117 val, ret, (unsigned long)len, (unsigned long)len_len);
118 return 1;
119 }
120
121 ret = der_get_integer(buf + 1, len, &dval, &len_len);
122 if (ret) {
123 printf("integer %d decode failed %d\n", val, ret);
124 return 1;
125 }
126 if (len != len_len) {
127 printf("integer %d decoded diffrent len %lu != %lu",
128 val, (unsigned long)len, (unsigned long)len_len);
129 return 1;
130 }
131 if (val != dval) {
132 printf("decode decoded to diffrent value %d != %d",
133 val, dval);
134 return 1;
135 }
136
137 if (buf[0] != (unsigned char)'\xff') {
138 printf("precanary dead %d\n", val);
139 return 1;
140 }
141 if (buf[len + 1] != (unsigned char)'\xff') {
142 printf("postecanary dead %d\n", val);
143 return 1;
144 }
145 free(buf);
146 return 0;
147 }
148
149 static int
150 test_integer_more (void)
151 {
152 int i, n1, n2, n3, n4, n5, n6;
153
154 n2 = 0;
155 for (i = 0; i < (sizeof(int) * 8); i++) {
156 n1 = 0x01 << i;
157 n2 = n2 | n1;
158 n3 = ~n1;
159 n4 = ~n2;
160 n5 = (-1) & ~(0x3f << i);
161 n6 = (-1) & ~(0x7f << i);
162
163 test_one_int(n1);
164 test_one_int(n2);
165 test_one_int(n3);
166 test_one_int(n4);
167 test_one_int(n5);
168 test_one_int(n6);
169 }
170 return 0;
171 }
172
173 static int
174 cmp_unsigned (void *a, void *b)
175 {
176 return *(unsigned int*)b - *(unsigned int*)a;
177 }
178
179 static int
180 test_unsigned (void)
181 {
182 struct test_case tests[] = {
183 {NULL, 1, "\x00"},
184 {NULL, 1, "\x7f"},
185 {NULL, 2, "\x00\x80"},
186 {NULL, 2, "\x01\x00"},
187 {NULL, 2, "\x02\x00"},
188 {NULL, 3, "\x00\x80\x00"},
189 {NULL, 5, "\x00\x80\x00\x00\x00"},
190 {NULL, 4, "\x7f\xff\xff\xff"}
191 };
192
193 unsigned int values[] = {0, 127, 128, 256, 512, 32768,
194 0x80000000, 0x7fffffff};
195 int i, ret;
196 int ntests = sizeof(tests) / sizeof(*tests);
197
198 for (i = 0; i < ntests; ++i) {
199 tests[i].val = &values[i];
200 asprintf (&tests[i].name, "unsigned %u", values[i]);
201 if (tests[i].name == NULL)
202 errx(1, "malloc");
203 }
204
205 ret = generic_test (tests, ntests, sizeof(int),
206 (generic_encode)der_put_unsigned,
207 (generic_length)der_length_unsigned,
208 (generic_decode)der_get_unsigned,
209 (generic_free)NULL,
210 cmp_unsigned);
211 for (i = 0; i < ntests; ++i)
212 free (tests[i].name);
213 return ret;
214 }
215
216 static int
217 cmp_octet_string (void *a, void *b)
218 {
219 heim_octet_string *oa = (heim_octet_string *)a;
220 heim_octet_string *ob = (heim_octet_string *)b;
221
222 if (oa->length != ob->length)
223 return ob->length - oa->length;
224
225 return (memcmp (oa->data, ob->data, oa->length));
226 }
227
228 static int
229 test_octet_string (void)
230 {
231 heim_octet_string s1 = {8, "\x01\x23\x45\x67\x89\xab\xcd\xef"};
232
233 struct test_case tests[] = {
234 {NULL, 8, "\x01\x23\x45\x67\x89\xab\xcd\xef"}
235 };
236 int ntests = sizeof(tests) / sizeof(*tests);
237 int ret;
238
239 tests[0].val = &s1;
240 asprintf (&tests[0].name, "a octet string");
241 if (tests[0].name == NULL)
242 errx(1, "malloc");
243
244 ret = generic_test (tests, ntests, sizeof(heim_octet_string),
245 (generic_encode)der_put_octet_string,
246 (generic_length)der_length_octet_string,
247 (generic_decode)der_get_octet_string,
248 (generic_free)der_free_octet_string,
249 cmp_octet_string);
250 free(tests[0].name);
251 return ret;
252 }
253
254 static int
255 cmp_bmp_string (void *a, void *b)
256 {
257 heim_bmp_string *oa = (heim_bmp_string *)a;
258 heim_bmp_string *ob = (heim_bmp_string *)b;
259
260 return der_heim_bmp_string_cmp(oa, ob);
261 }
262
263 static uint16_t bmp_d1[] = { 32 };
264 static uint16_t bmp_d2[] = { 32, 32 };
265
266 static int
267 test_bmp_string (void)
268 {
269 heim_bmp_string s1 = { 1, bmp_d1 };
270 heim_bmp_string s2 = { 2, bmp_d2 };
271
272 struct test_case tests[] = {
273 {NULL, 2, "\x00\x20"},
274 {NULL, 4, "\x00\x20\x00\x20"}
275 };
276 int ntests = sizeof(tests) / sizeof(*tests);
277 int ret;
278
279 tests[0].val = &s1;
280 asprintf (&tests[0].name, "a bmp string");
281 if (tests[0].name == NULL)
282 errx(1, "malloc");
283 tests[1].val = &s2;
284 asprintf (&tests[1].name, "second bmp string");
285 if (tests[1].name == NULL)
286 errx(1, "malloc");
287
288 ret = generic_test (tests, ntests, sizeof(heim_bmp_string),
289 (generic_encode)der_put_bmp_string,
290 (generic_length)der_length_bmp_string,
291 (generic_decode)der_get_bmp_string,
292 (generic_free)der_free_bmp_string,
293 cmp_bmp_string);
294 free(tests[0].name);
295 free(tests[1].name);
296 return ret;
297 }
298
299 static int
300 cmp_universal_string (void *a, void *b)
301 {
302 heim_universal_string *oa = (heim_universal_string *)a;
303 heim_universal_string *ob = (heim_universal_string *)b;
304
305 return der_heim_universal_string_cmp(oa, ob);
306 }
307
308 static uint32_t universal_d1[] = { 32 };
309 static uint32_t universal_d2[] = { 32, 32 };
310
311 static int
312 test_universal_string (void)
313 {
314 heim_universal_string s1 = { 1, universal_d1 };
315 heim_universal_string s2 = { 2, universal_d2 };
316
317 struct test_case tests[] = {
318 {NULL, 4, "\x00\x00\x00\x20"},
319 {NULL, 8, "\x00\x00\x00\x20\x00\x00\x00\x20"}
320 };
321 int ntests = sizeof(tests) / sizeof(*tests);
322 int ret;
323
324 tests[0].val = &s1;
325 asprintf (&tests[0].name, "a universal string");
326 if (tests[0].name == NULL)
327 errx(1, "malloc");
328 tests[1].val = &s2;
329 asprintf (&tests[1].name, "second universal string");
330 if (tests[1].name == NULL)
331 errx(1, "malloc");
332
333 ret = generic_test (tests, ntests, sizeof(heim_universal_string),
334 (generic_encode)der_put_universal_string,
335 (generic_length)der_length_universal_string,
336 (generic_decode)der_get_universal_string,
337 (generic_free)der_free_universal_string,
338 cmp_universal_string);
339 free(tests[0].name);
340 free(tests[1].name);
341 return ret;
342 }
343
344 static int
345 cmp_general_string (void *a, void *b)
346 {
347 char **sa = (char **)a;
348 char **sb = (char **)b;
349
350 return strcmp (*sa, *sb);
351 }
352
353 static int
354 test_general_string (void)
355 {
356 char *s1 = "Test User 1";
357
358 struct test_case tests[] = {
359 {NULL, 11, "\x54\x65\x73\x74\x20\x55\x73\x65\x72\x20\x31"}
360 };
361 int ret, ntests = sizeof(tests) / sizeof(*tests);
362
363 tests[0].val = &s1;
364 asprintf (&tests[0].name, "the string \"%s\"", s1);
365 if (tests[0].name == NULL)
366 errx(1, "malloc");
367
368 ret = generic_test (tests, ntests, sizeof(unsigned char *),
369 (generic_encode)der_put_general_string,
370 (generic_length)der_length_general_string,
371 (generic_decode)der_get_general_string,
372 (generic_free)der_free_general_string,
373 cmp_general_string);
374 free(tests[0].name);
375 return ret;
376 }
377
378 static int
379 cmp_generalized_time (void *a, void *b)
380 {
381 time_t *ta = (time_t *)a;
382 time_t *tb = (time_t *)b;
383
384 return *tb - *ta;
385 }
386
387 static int
388 test_generalized_time (void)
389 {
390 struct test_case tests[] = {
391 {NULL, 15, "19700101000000Z"},
392 {NULL, 15, "19851106210627Z"}
393 };
394 time_t values[] = {0, 500159187};
395 int i, ret;
396 int ntests = sizeof(tests) / sizeof(*tests);
397
398 for (i = 0; i < ntests; ++i) {
399 tests[i].val = &values[i];
400 asprintf (&tests[i].name, "time %d", (int)values[i]);
401 if (tests[i].name == NULL)
402 errx(1, "malloc");
403 }
404
405 ret = generic_test (tests, ntests, sizeof(time_t),
406 (generic_encode)der_put_generalized_time,
407 (generic_length)der_length_generalized_time,
408 (generic_decode)der_get_generalized_time,
409 (generic_free)NULL,
410 cmp_generalized_time);
411 for (i = 0; i < ntests; ++i)
412 free(tests[i].name);
413 return ret;
414 }
415
416 static int
417 test_cmp_oid (void *a, void *b)
418 {
419 return der_heim_oid_cmp((heim_oid *)a, (heim_oid *)b);
420 }
421
422 static unsigned oid_comp1[] = { 1, 1, 1 };
423 static unsigned oid_comp2[] = { 1, 1 };
424 static unsigned oid_comp3[] = { 6, 15, 1 };
425 static unsigned oid_comp4[] = { 6, 15 };
426
427 static int
428 test_oid (void)
429 {
430 struct test_case tests[] = {
431 {NULL, 2, "\x29\x01"},
432 {NULL, 1, "\x29"},
433 {NULL, 2, "\xff\x01"},
434 {NULL, 1, "\xff"}
435 };
436 heim_oid values[] = {
437 { 3, oid_comp1 },
438 { 2, oid_comp2 },
439 { 3, oid_comp3 },
440 { 2, oid_comp4 }
441 };
442 int i, ret;
443 int ntests = sizeof(tests) / sizeof(*tests);
444
445 for (i = 0; i < ntests; ++i) {
446 tests[i].val = &values[i];
447 asprintf (&tests[i].name, "oid %d", i);
448 if (tests[i].name == NULL)
449 errx(1, "malloc");
450 }
451
452 ret = generic_test (tests, ntests, sizeof(heim_oid),
453 (generic_encode)der_put_oid,
454 (generic_length)der_length_oid,
455 (generic_decode)der_get_oid,
456 (generic_free)der_free_oid,
457 test_cmp_oid);
458 for (i = 0; i < ntests; ++i)
459 free(tests[i].name);
460 return ret;
461 }
462
463 static int
464 test_cmp_bit_string (void *a, void *b)
465 {
466 return der_heim_bit_string_cmp((heim_bit_string *)a, (heim_bit_string *)b);
467 }
468
469 static int
470 test_bit_string (void)
471 {
472 struct test_case tests[] = {
473 {NULL, 1, "\x00"}
474 };
475 heim_bit_string values[] = {
476 { 0, "" }
477 };
478 int i, ret;
479 int ntests = sizeof(tests) / sizeof(*tests);
480
481 for (i = 0; i < ntests; ++i) {
482 tests[i].val = &values[i];
483 asprintf (&tests[i].name, "bit_string %d", i);
484 if (tests[i].name == NULL)
485 errx(1, "malloc");
486 }
487
488 ret = generic_test (tests, ntests, sizeof(heim_bit_string),
489 (generic_encode)der_put_bit_string,
490 (generic_length)der_length_bit_string,
491 (generic_decode)der_get_bit_string,
492 (generic_free)der_free_bit_string,
493 test_cmp_bit_string);
494 for (i = 0; i < ntests; ++i)
495 free(tests[i].name);
496 return ret;
497 }
498
499 static int
500 test_cmp_heim_integer (void *a, void *b)
501 {
502 return der_heim_integer_cmp((heim_integer *)a, (heim_integer *)b);
503 }
504
505 static int
506 test_heim_integer (void)
507 {
508 struct test_case tests[] = {
509 {NULL, 2, "\xfe\x01"},
510 {NULL, 2, "\xef\x01"},
511 {NULL, 3, "\xff\x00\xff"},
512 {NULL, 3, "\xff\x01\x00"},
513 {NULL, 1, "\x00"},
514 {NULL, 1, "\x01"},
515 {NULL, 2, "\x00\x80"}
516 };
517
518 heim_integer values[] = {
519 { 2, "\x01\xff", 1 },
520 { 2, "\x10\xff", 1 },
521 { 2, "\xff\x01", 1 },
522 { 2, "\xff\x00", 1 },
523 { 0, "", 0 },
524 { 1, "\x01", 0 },
525 { 1, "\x80", 0 }
526 };
527 int i, ret;
528 int ntests = sizeof(tests) / sizeof(tests[0]);
529 size_t size;
530 heim_integer i2;
531
532 for (i = 0; i < ntests; ++i) {
533 tests[i].val = &values[i];
534 asprintf (&tests[i].name, "heim_integer %d", i);
535 if (tests[i].name == NULL)
536 errx(1, "malloc");
537 }
538
539 ret = generic_test (tests, ntests, sizeof(heim_integer),
540 (generic_encode)der_put_heim_integer,
541 (generic_length)der_length_heim_integer,
542 (generic_decode)der_get_heim_integer,
543 (generic_free)der_free_heim_integer,
544 test_cmp_heim_integer);
545 for (i = 0; i < ntests; ++i)
546 free (tests[i].name);
547 if (ret)
548 return ret;
549
550 /* test zero length integer (BER format) */
551 ret = der_get_heim_integer(NULL, 0, &i2, &size);
552 if (ret)
553 errx(1, "der_get_heim_integer");
554 if (i2.length != 0)
555 errx(1, "der_get_heim_integer wrong length");
556 der_free_heim_integer(&i2);
557
558 return 0;
559 }
560
561 static int
562 test_cmp_boolean (void *a, void *b)
563 {
564 return !!*(int *)a != !!*(int *)b;
565 }
566
567 static int
568 test_boolean (void)
569 {
570 struct test_case tests[] = {
571 {NULL, 1, "\xff"},
572 {NULL, 1, "\x00"}
573 };
574
575 int values[] = { 1, 0 };
576 int i, ret;
577 int ntests = sizeof(tests) / sizeof(tests[0]);
578 size_t size;
579 heim_integer i2;
580
581 for (i = 0; i < ntests; ++i) {
582 tests[i].val = &values[i];
583 asprintf (&tests[i].name, "heim_boolean %d", i);
584 if (tests[i].name == NULL)
585 errx(1, "malloc");
586 }
587
588 ret = generic_test (tests, ntests, sizeof(int),
589 (generic_encode)der_put_boolean,
590 (generic_length)der_length_boolean,
591 (generic_decode)der_get_boolean,
592 (generic_free)NULL,
593 test_cmp_boolean);
594 for (i = 0; i < ntests; ++i)
595 free (tests[i].name);
596 if (ret)
597 return ret;
598
599 /* test zero length integer (BER format) */
600 ret = der_get_heim_integer(NULL, 0, &i2, &size);
601 if (ret)
602 errx(1, "der_get_heim_integer");
603 if (i2.length != 0)
604 errx(1, "der_get_heim_integer wrong length");
605 der_free_heim_integer(&i2);
606
607 return 0;
608 }
609
610 static int
611 check_fail_unsigned(void)
612 {
613 struct test_case tests[] = {
614 {NULL, sizeof(unsigned) + 1,
615 "\x01\x01\x01\x01\x01\x01\x01\x01\x01", "data overrun" }
616 };
617 int ntests = sizeof(tests) / sizeof(*tests);
618
619 return generic_decode_fail(tests, ntests, sizeof(unsigned),
620 (generic_decode)der_get_unsigned);
621 }
622
623 static int
624 check_fail_integer(void)
625 {
626 struct test_case tests[] = {
627 {NULL, sizeof(int) + 1,
628 "\x01\x01\x01\x01\x01\x01\x01\x01\x01", "data overrun" }
629 };
630 int ntests = sizeof(tests) / sizeof(*tests);
631
632 return generic_decode_fail(tests, ntests, sizeof(int),
633 (generic_decode)der_get_integer);
634 }
635
636 static int
637 check_fail_length(void)
638 {
639 struct test_case tests[] = {
640 {NULL, 0, "", "empty input data"},
641 {NULL, 1, "\x82", "internal length overrun" }
642 };
643 int ntests = sizeof(tests) / sizeof(*tests);
644
645 return generic_decode_fail(tests, ntests, sizeof(size_t),
646 (generic_decode)der_get_length);
647 }
648
649 static int
650 check_fail_boolean(void)
651 {
652 struct test_case tests[] = {
653 {NULL, 0, "", "empty input data"}
654 };
655 int ntests = sizeof(tests) / sizeof(*tests);
656
657 return generic_decode_fail(tests, ntests, sizeof(int),
658 (generic_decode)der_get_boolean);
659 }
660
661 static int
662 check_fail_general_string(void)
663 {
664 struct test_case tests[] = {
665 { NULL, 3, "A\x00i", "NUL char in string"}
666 };
667 int ntests = sizeof(tests) / sizeof(*tests);
668
669 return generic_decode_fail(tests, ntests, sizeof(heim_general_string),
670 (generic_decode)der_get_general_string);
671 }
672
673 static int
674 check_fail_bmp_string(void)
675 {
676 struct test_case tests[] = {
677 {NULL, 1, "\x00", "odd (1) length bmpstring"},
678 {NULL, 3, "\x00\x00\x00", "odd (3) length bmpstring"}
679 };
680 int ntests = sizeof(tests) / sizeof(*tests);
681
682 return generic_decode_fail(tests, ntests, sizeof(heim_bmp_string),
683 (generic_decode)der_get_bmp_string);
684 }
685
686 static int
687 check_fail_universal_string(void)
688 {
689 struct test_case tests[] = {
690 {NULL, 1, "\x00", "x & 3 == 1 universal string"},
691 {NULL, 2, "\x00\x00", "x & 3 == 2 universal string"},
692 {NULL, 3, "\x00\x00\x00", "x & 3 == 3 universal string"},
693 {NULL, 5, "\x00\x00\x00\x00\x00", "x & 3 == 1 universal string"},
694 {NULL, 6, "\x00\x00\x00\x00\x00\x00", "x & 3 == 2 universal string"},
695 {NULL, 7, "\x00\x00\x00\x00\x00\x00\x00", "x & 3 == 3 universal string"}
696 };
697 int ntests = sizeof(tests) / sizeof(*tests);
698
699 return generic_decode_fail(tests, ntests, sizeof(heim_universal_string),
700 (generic_decode)der_get_universal_string);
701 }
702
703 static int
704 check_fail_heim_integer(void)
705 {
706 #if 0
707 struct test_case tests[] = {
708 };
709 int ntests = sizeof(tests) / sizeof(*tests);
710
711 return generic_decode_fail(tests, ntests, sizeof(heim_integer),
712 (generic_decode)der_get_heim_integer);
713 #else
714 return 0;
715 #endif
716 }
717
718 static int
719 check_fail_generalized_time(void)
720 {
721 struct test_case tests[] = {
722 {NULL, 1, "\x00", "no time"}
723 };
724 int ntests = sizeof(tests) / sizeof(*tests);
725
726 return generic_decode_fail(tests, ntests, sizeof(time_t),
727 (generic_decode)der_get_generalized_time);
728 }
729
730 static int
731 check_fail_oid(void)
732 {
733 struct test_case tests[] = {
734 {NULL, 0, "", "empty input data"},
735 {NULL, 2, "\x00\x80", "last byte continuation" },
736 {NULL, 11, "\x00\x81\x80\x80\x80\x80\x80\x80\x80\x80\x00",
737 "oid element overflow" }
738 };
739 int ntests = sizeof(tests) / sizeof(*tests);
740
741 return generic_decode_fail(tests, ntests, sizeof(heim_oid),
742 (generic_decode)der_get_oid);
743 }
744
745 static int
746 check_fail_bitstring(void)
747 {
748 struct test_case tests[] = {
749 {NULL, 0, "", "empty input data"},
750 {NULL, 1, "\x08", "larger then 8 bits trailer"},
751 {NULL, 1, "\x01", "to few bytes for bits"},
752 {NULL, -2, "\x00", "length overrun"},
753 {NULL, -1, "", "length to short"}
754 };
755 int ntests = sizeof(tests) / sizeof(*tests);
756
757 return generic_decode_fail(tests, ntests, sizeof(heim_bit_string),
758 (generic_decode)der_get_bit_string);
759 }
760
761 static int
762 check_heim_integer_same(const char *p, const char *norm_p, heim_integer *i)
763 {
764 heim_integer i2;
765 char *str;
766 int ret;
767
768 ret = der_print_hex_heim_integer(i, &str);
769 if (ret)
770 errx(1, "der_print_hex_heim_integer: %d", ret);
771
772 if (strcmp(str, norm_p) != 0)
773 errx(1, "der_print_hex_heim_integer: %s != %s", str, p);
774
775 ret = der_parse_hex_heim_integer(str, &i2);
776 if (ret)
777 errx(1, "der_parse_hex_heim_integer: %d", ret);
778
779 if (der_heim_integer_cmp(i, &i2) != 0)
780 errx(1, "der_heim_integer_cmp: p %s", p);
781
782 der_free_heim_integer(&i2);
783 free(str);
784
785 ret = der_parse_hex_heim_integer(p, &i2);
786 if (ret)
787 errx(1, "der_parse_hex_heim_integer: %d", ret);
788
789 if (der_heim_integer_cmp(i, &i2) != 0)
790 errx(1, "der_heim_integer_cmp: norm");
791
792 der_free_heim_integer(&i2);
793
794 return 0;
795 }
796
797 static int
798 test_heim_int_format(void)
799 {
800 heim_integer i = { 1, "\x10", 0 };
801 heim_integer i2 = { 1, "\x10", 1 };
802 heim_integer i3 = { 1, "\01", 0 };
803 char *p =
804 "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1"
805 "29024E08" "8A67CC74" "020BBEA6" "3B139B22" "514A0879" "8E3404DD"
806 "EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" "4FE1356D" "6D51C245"
807 "E485B576" "625E7EC6" "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED"
808 "EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" "49286651" "ECE65381"
809 "FFFFFFFF" "FFFFFFFF";
810 heim_integer bni = {
811 128,
812 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC9\x0F\xDA\xA2"
813 "\x21\x68\xC2\x34\xC4\xC6\x62\x8B\x80\xDC\x1C\xD1"
814 "\x29\x02\x4E\x08\x8A\x67\xCC\x74\x02\x0B\xBE\xA6"
815 "\x3B\x13\x9B\x22\x51\x4A\x08\x79\x8E\x34\x04\xDD"
816 "\xEF\x95\x19\xB3\xCD\x3A\x43\x1B\x30\x2B\x0A\x6D"
817 "\xF2\x5F\x14\x37\x4F\xE1\x35\x6D\x6D\x51\xC2\x45"
818 "\xE4\x85\xB5\x76\x62\x5E\x7E\xC6\xF4\x4C\x42\xE9"
819 "\xA6\x37\xED\x6B\x0B\xFF\x5C\xB6\xF4\x06\xB7\xED"
820 "\xEE\x38\x6B\xFB\x5A\x89\x9F\xA5\xAE\x9F\x24\x11"
821 "\x7C\x4B\x1F\xE6\x49\x28\x66\x51\xEC\xE6\x53\x81"
822 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
823 0
824 };
825 heim_integer f;
826 int ret = 0;
827
828 ret += check_heim_integer_same(p, p, &bni);
829 ret += check_heim_integer_same("10", "10", &i);
830 ret += check_heim_integer_same("00000010", "10", &i);
831 ret += check_heim_integer_same("-10", "-10", &i2);
832 ret += check_heim_integer_same("-00000010", "-10", &i2);
833 ret += check_heim_integer_same("01", "01", &i3);
834 ret += check_heim_integer_same("1", "01", &i3);
835
836 {
837 int r;
838 r = der_parse_hex_heim_integer("-", &f);
839 if (r == 0) {
840 der_free_heim_integer(&f);
841 ret++;
842 }
843 /* used to cause UMR */
844 r = der_parse_hex_heim_integer("00", &f);
845 if (r == 0)
846 der_free_heim_integer(&f);
847 else
848 ret++;
849 }
850
851 return ret;
852 }
853
854 static int
855 test_heim_oid_format_same(const char *str, const heim_oid *oid)
856 {
857 int ret;
858 char *p;
859 heim_oid o2;
860
861 ret = der_print_heim_oid(oid, ' ', &p);
862 if (ret) {
863 printf("fail to print oid: %s\n", str);
864 return 1;
865 }
866 ret = strcmp(p, str);
867 if (ret) {
868 printf("oid %s != formated oid %s\n", str, p);
869 free(p);
870 return ret;
871 }
872
873 ret = der_parse_heim_oid(p, " ", &o2);
874 if (ret) {
875 printf("failed to parse %s\n", p);
876 free(p);
877 return ret;
878 }
879 free(p);
880 ret = der_heim_oid_cmp(&o2, oid);
881 der_free_oid(&o2);
882
883 return ret;
884 }
885
886 static unsigned sha1_oid_tree[] = { 1, 3, 14, 3, 2, 26 };
887
888 static int
889 test_heim_oid_format(void)
890 {
891 heim_oid sha1 = { 6, sha1_oid_tree };
892 int ret = 0;
893
894 ret += test_heim_oid_format_same("1 3 14 3 2 26", &sha1);
895
896 return ret;
897 }
898
899 static int
900 check_trailing_nul(void)
901 {
902 int i, ret;
903 struct {
904 int fail;
905 const unsigned char *p;
906 size_t len;
907 const char *s;
908 size_t size;
909 } foo[] = {
910 { 1, (const unsigned char *)"foo\x00o", 5, NULL, 0 },
911 { 1, (const unsigned char *)"\x00o", 2, NULL, 0 },
912 { 0, (const unsigned char *)"\x00\x00\x00\x00\x00", 5, "", 5 },
913 { 0, (const unsigned char *)"\x00", 1, "", 1 },
914 { 0, (const unsigned char *)"", 0, "", 0 },
915 { 0, (const unsigned char *)"foo\x00\x00", 5, "foo", 5 },
916 { 0, (const unsigned char *)"foo\0", 4, "foo", 4 },
917 { 0, (const unsigned char *)"foo", 3, "foo", 3 }
918 };
919
920 for (i = 0; i < sizeof(foo)/sizeof(foo[0]); i++) {
921 char *s;
922 size_t size;
923 ret = der_get_general_string(foo[i].p, foo[i].len, &s, &size);
924 if (foo[i].fail) {
925 if (ret == 0)
926 errx(1, "check %d NULL didn't fail", i);
927 continue;
928 }
929 if (ret)
930 errx(1, "NULL check %d der_get_general_string failed", i);
931 if (foo[i].size != size)
932 errx(1, "NUL check i = %d size failed", i);
933 if (strcmp(foo[i].s, s) != 0)
934 errx(1, "NUL check i = %d content failed", i);
935 free(s);
936 }
937 return 0;
938 }
939
940 static int
941 test_misc_cmp(void)
942 {
943 int ret;
944
945 /* diffrent lengths are diffrent */
946 {
947 const heim_octet_string os1 = { 1, "a" } , os2 = { 0, NULL };
948 ret = der_heim_octet_string_cmp(&os1, &os2);
949 if (ret == 0)
950 return 1;
951 }
952 /* diffrent data are diffrent */
953 {
954 const heim_octet_string os1 = { 1, "a" } , os2 = { 1, "b" };
955 ret = der_heim_octet_string_cmp(&os1, &os2);
956 if (ret == 0)
957 return 1;
958 }
959 /* diffrent lengths are diffrent */
960 {
961 const heim_bit_string bs1 = { 8, "a" } , bs2 = { 7, "a" };
962 ret = der_heim_bit_string_cmp(&bs1, &bs2);
963 if (ret == 0)
964 return 1;
965 }
966 /* diffrent data are diffrent */
967 {
968 const heim_bit_string bs1 = { 7, "\x0f" } , bs2 = { 7, "\x02" };
969 ret = der_heim_bit_string_cmp(&bs1, &bs2);
970 if (ret == 0)
971 return 1;
972 }
973 /* diffrent lengths are diffrent */
974 {
975 uint16_t data = 1;
976 heim_bmp_string bs1 = { 1, NULL } , bs2 = { 0, NULL };
977 bs1.data = &data;
978 ret = der_heim_bmp_string_cmp(&bs1, &bs2);
979 if (ret == 0)
980 return 1;
981 }
982 /* diffrent lengths are diffrent */
983 {
984 uint32_t data;
985 heim_universal_string us1 = { 1, NULL } , us2 = { 0, NULL };
986 us1.data = &data;
987 ret = der_heim_universal_string_cmp(&us1, &us2);
988 if (ret == 0)
989 return 1;
990 }
991 /* same */
992 {
993 uint32_t data = (uint32_t)'a';
994 heim_universal_string us1 = { 1, NULL } , us2 = { 1, NULL };
995 us1.data = &data;
996 us2.data = &data;
997 ret = der_heim_universal_string_cmp(&us1, &us2);
998 if (ret != 0)
999 return 1;
1000 }
1001
1002 return 0;
1003 }
1004
1005 static int
1006 corner_generalized_time(void)
1007 {
1008 const char *str = "760520140000Z";
1009 size_t size;
1010 time_t t;
1011 int ret;
1012
1013 ret = der_get_generalized_time((const unsigned char*)str, strlen(str),
1014 &t, &size);
1015 if (ret)
1016 return 1;
1017 return 0;
1018 }
1019
1020 static int
1021 corner_tag(void)
1022 {
1023 struct {
1024 int ok;
1025 const char *ptr;
1026 size_t len;
1027 } tests[] = {
1028 { 1, "\x00", 1 },
1029 { 0, "\xff", 1 },
1030 { 0, "\xff\xff\xff\xff\xff\xff\xff\xff", 8 }
1031 };
1032 int i, ret;
1033 Der_class cl;
1034 Der_type ty;
1035 unsigned int tag;
1036 size_t size;
1037
1038 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
1039 ret = der_get_tag((const unsigned char*)tests[i].ptr,
1040 tests[i].len, &cl, &ty, &tag, &size);
1041 if (ret) {
1042 if (tests[i].ok)
1043 errx(1, "failed while shouldn't");
1044 } else {
1045 if (!tests[i].ok)
1046 errx(1, "passed while shouldn't");
1047 }
1048 }
1049 return 0;
1050 }
1051
1052 int
1053 main(int argc, char **argv)
1054 {
1055 int ret = 0;
1056
1057 ret += test_integer ();
1058 ret += test_integer_more();
1059 ret += test_unsigned ();
1060 ret += test_octet_string ();
1061 ret += test_bmp_string ();
1062 ret += test_universal_string ();
1063 ret += test_general_string ();
1064 ret += test_generalized_time ();
1065 ret += test_oid ();
1066 ret += test_bit_string();
1067 ret += test_heim_integer();
1068 ret += test_boolean();
1069
1070 ret += check_fail_unsigned();
1071 ret += check_fail_integer();
1072 ret += check_fail_length();
1073 ret += check_fail_boolean();
1074 ret += check_fail_general_string();
1075 ret += check_fail_bmp_string();
1076 ret += check_fail_universal_string();
1077 ret += check_fail_heim_integer();
1078 ret += check_fail_generalized_time();
1079 ret += check_fail_oid();
1080 ret += check_fail_bitstring();
1081 ret += test_heim_int_format();
1082 ret += test_heim_oid_format();
1083 ret += check_trailing_nul();
1084 ret += test_misc_cmp();
1085 ret += corner_generalized_time();
1086 ret += corner_tag();
1087
1088 return ret;
1089 }
Heimdal