?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
quel 64bit warnings, fixup implicit encoding for template, fix spelling
[heimdal.git] / lib / asn1 / check-gen.c
blob68c8b5c369a64114ae6ca84e732144c54b88415a
1 /*
2 * Copyright (c) 1999 - 2005 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 <config.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <err.h>
40 #include <roken.h>
41
42 #include <asn1-common.h>
43 #include <asn1_err.h>
44 #include <der.h>
45 #include <krb5_asn1.h>
46 #include <heim_asn1.h>
47 #include <rfc2459_asn1.h>
48 #include <test_asn1.h>
49 #include <cms_asn1.h>
50
51 #include "check-common.h"
52
53 static char *lha_principal[] = { "lha" };
54 static char *lharoot_princ[] = { "lha", "root" };
55 static char *datan_princ[] = { "host", "nutcracker.e.kth.se" };
56 static char *nada_tgt_principal[] = { "krbtgt", "NADA.KTH.SE" };
57
58
59 #define IF_OPT_COMPARE(ac,bc,e) \
60 if (((ac)->e == NULL && (bc)->e != NULL) || (((ac)->e != NULL && (bc)->e == NULL))) return 1; if ((ab)->e)
61 #define COMPARE_OPT_STRING(ac,bc,e) \
62 do { if (strcmp(*(ac)->e, *(bc)->e) != 0) return 1; } while(0)
63 #define COMPARE_OPT_OCTECT_STRING(ac,bc,e) \
64 do { if ((ac)->e->length != (bc)->e->length || memcmp((ac)->e->data, (bc)->e->data, (ac)->e->length) != 0) return 1; } while(0)
65 #define COMPARE_STRING(ac,bc,e) \
66 do { if (strcmp((ac)->e, (bc)->e) != 0) return 1; } while(0)
67 #define COMPARE_INTEGER(ac,bc,e) \
68 do { if ((ac)->e != (bc)->e) return 1; } while(0)
69 #define COMPARE_OPT_INTEGER(ac,bc,e) \
70 do { if (*(ac)->e != *(bc)->e) return 1; } while(0)
71 #define COMPARE_MEM(ac,bc,e,len) \
72 do { if (memcmp((ac)->e, (bc)->e,len) != 0) return 1; } while(0)
73 #define COMPARE_OCTECT_STRING(ac,bc,e) \
74 do { if ((ac)->e.length != (bc)->e.length || memcmp((ac)->e.data, (bc)->e.data, (ac)->e.length) != 0) return 1; } while(0)
75
76 static int
77 cmp_principal (void *a, void *b)
78 {
79 Principal *pa = a;
80 Principal *pb = b;
81 int i;
82
83 COMPARE_STRING(pa,pb,realm);
84 COMPARE_INTEGER(pa,pb,name.name_type);
85 COMPARE_INTEGER(pa,pb,name.name_string.len);
86
87 for (i = 0; i < pa->name.name_string.len; i++)
88 COMPARE_STRING(pa,pb,name.name_string.val[i]);
89
90 return 0;
91 }
92
93 static int
94 test_principal (void)
95 {
96
97 struct test_case tests[] = {
98 { NULL, 29,
99 "\x30\x1b\xa0\x10\x30\x0e\xa0\x03\x02\x01\x01\xa1\x07\x30\x05\x1b"
100 "\x03\x6c\x68\x61\xa1\x07\x1b\x05\x53\x55\x2e\x53\x45",
101 NULL
102 },
103 { NULL, 35,
104 "\x30\x21\xa0\x16\x30\x14\xa0\x03\x02\x01\x01\xa1\x0d\x30\x0b\x1b"
105 "\x03\x6c\x68\x61\x1b\x04\x72\x6f\x6f\x74\xa1\x07\x1b\x05\x53\x55"
106 "\x2e\x53\x45",
107 NULL
108 },
109 { NULL, 54,
110 "\x30\x34\xa0\x26\x30\x24\xa0\x03\x02\x01\x03\xa1\x1d\x30\x1b\x1b"
111 "\x04\x68\x6f\x73\x74\x1b\x13\x6e\x75\x74\x63\x72\x61\x63\x6b\x65"
112 "\x72\x2e\x65\x2e\x6b\x74\x68\x2e\x73\x65\xa1\x0a\x1b\x08\x45\x2e"
113 "\x4b\x54\x48\x2e\x53\x45",
114 NULL
115 }
116 };
117
118
119 Principal values[] = {
120 { { KRB5_NT_PRINCIPAL, { 1, lha_principal } }, "SU.SE" },
121 { { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } }, "SU.SE" },
122 { { KRB5_NT_SRV_HST, { 2, datan_princ } }, "E.KTH.SE" }
123 };
124 int i, ret;
125 int ntests = sizeof(tests) / sizeof(*tests);
126
127 for (i = 0; i < ntests; ++i) {
128 tests[i].val = &values[i];
129 if (asprintf (&tests[i].name, "Principal %d", i) < 0)
130 errx(1, "malloc");
131 if (tests[i].name == NULL)
132 errx(1, "malloc");
133 }
134
135 ret = generic_test (tests, ntests, sizeof(Principal),
136 (generic_encode)encode_Principal,
137 (generic_length)length_Principal,
138 (generic_decode)decode_Principal,
139 (generic_free)free_Principal,
140 cmp_principal,
141 NULL);
142 for (i = 0; i < ntests; ++i)
143 free (tests[i].name);
144
145 return ret;
146 }
147
148 static int
149 cmp_authenticator (void *a, void *b)
150 {
151 Authenticator *aa = a;
152 Authenticator *ab = b;
153 int i;
154
155 COMPARE_INTEGER(aa,ab,authenticator_vno);
156 COMPARE_STRING(aa,ab,crealm);
157
158 COMPARE_INTEGER(aa,ab,cname.name_type);
159 COMPARE_INTEGER(aa,ab,cname.name_string.len);
160
161 for (i = 0; i < aa->cname.name_string.len; i++)
162 COMPARE_STRING(aa,ab,cname.name_string.val[i]);
163
164 return 0;
165 }
166
167 static int
168 test_authenticator (void)
169 {
170 struct test_case tests[] = {
171 { NULL, 63,
172 "\x62\x3d\x30\x3b\xa0\x03\x02\x01\x05\xa1\x0a\x1b\x08"
173 "\x45\x2e\x4b\x54\x48\x2e\x53\x45\xa2\x10\x30\x0e\xa0"
174 "\x03\x02\x01\x01\xa1\x07\x30\x05\x1b\x03\x6c\x68\x61"
175 "\xa4\x03\x02\x01\x0a\xa5\x11\x18\x0f\x31\x39\x37\x30"
176 "\x30\x31\x30\x31\x30\x30\x30\x31\x33\x39\x5a",
177 NULL
178 },
179 { NULL, 67,
180 "\x62\x41\x30\x3f\xa0\x03\x02\x01\x05\xa1\x07\x1b\x05"
181 "\x53\x55\x2e\x53\x45\xa2\x16\x30\x14\xa0\x03\x02\x01"
182 "\x01\xa1\x0d\x30\x0b\x1b\x03\x6c\x68\x61\x1b\x04\x72"
183 "\x6f\x6f\x74\xa4\x04\x02\x02\x01\x24\xa5\x11\x18\x0f"
184 "\x31\x39\x37\x30\x30\x31\x30\x31\x30\x30\x31\x36\x33"
185 "\x39\x5a",
186 NULL
187 }
188 };
189
190 Authenticator values[] = {
191 { 5, "E.KTH.SE", { KRB5_NT_PRINCIPAL, { 1, lha_principal } },
192 NULL, 10, 99, NULL, NULL, NULL },
193 { 5, "SU.SE", { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } },
194 NULL, 292, 999, NULL, NULL, NULL }
195 };
196 int i, ret;
197 int ntests = sizeof(tests) / sizeof(*tests);
198
199 for (i = 0; i < ntests; ++i) {
200 tests[i].val = &values[i];
201 if (asprintf (&tests[i].name, "Authenticator %d", i) < 0)
202 errx(1, "malloc");
203 if (tests[i].name == NULL)
204 errx(1, "malloc");
205 }
206
207 ret = generic_test (tests, ntests, sizeof(Authenticator),
208 (generic_encode)encode_Authenticator,
209 (generic_length)length_Authenticator,
210 (generic_decode)decode_Authenticator,
211 (generic_free)free_Authenticator,
212 cmp_authenticator,
213 (generic_copy)copy_Authenticator);
214 for (i = 0; i < ntests; ++i)
215 free(tests[i].name);
216
217 return ret;
218 }
219
220 static int
221 cmp_KRB_ERROR (void *a, void *b)
222 {
223 KRB_ERROR *aa = a;
224 KRB_ERROR *ab = b;
225 int i;
226
227 COMPARE_INTEGER(aa,ab,pvno);
228 COMPARE_INTEGER(aa,ab,msg_type);
229
230 IF_OPT_COMPARE(aa,ab,ctime) {
231 COMPARE_INTEGER(aa,ab,ctime);
232 }
233 IF_OPT_COMPARE(aa,ab,cusec) {
234 COMPARE_INTEGER(aa,ab,cusec);
235 }
236 COMPARE_INTEGER(aa,ab,stime);
237 COMPARE_INTEGER(aa,ab,susec);
238 COMPARE_INTEGER(aa,ab,error_code);
239
240 IF_OPT_COMPARE(aa,ab,crealm) {
241 COMPARE_OPT_STRING(aa,ab,crealm);
242 }
243 #if 0
244 IF_OPT_COMPARE(aa,ab,cname) {
245 COMPARE_OPT_STRING(aa,ab,cname);
246 }
247 #endif
248 COMPARE_STRING(aa,ab,realm);
249
250 COMPARE_INTEGER(aa,ab,sname.name_string.len);
251 for (i = 0; i < aa->sname.name_string.len; i++)
252 COMPARE_STRING(aa,ab,sname.name_string.val[i]);
253
254 IF_OPT_COMPARE(aa,ab,e_text) {
255 COMPARE_OPT_STRING(aa,ab,e_text);
256 }
257 IF_OPT_COMPARE(aa,ab,e_data) {
258 /* COMPARE_OPT_OCTECT_STRING(aa,ab,e_data); */
259 }
260
261 return 0;
262 }
263
264 static int
265 test_krb_error (void)
266 {
267 struct test_case tests[] = {
268 { NULL, 127,
269 "\x7e\x7d\x30\x7b\xa0\x03\x02\x01\x05\xa1\x03\x02\x01\x1e\xa4\x11"
270 "\x18\x0f\x32\x30\x30\x33\x31\x31\x32\x34\x30\x30\x31\x31\x31\x39"
271 "\x5a\xa5\x05\x02\x03\x04\xed\xa5\xa6\x03\x02\x01\x1f\xa7\x0d\x1b"
272 "\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45\xa8\x10\x30\x0e"
273 "\xa0\x03\x02\x01\x01\xa1\x07\x30\x05\x1b\x03\x6c\x68\x61\xa9\x0d"
274 "\x1b\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45\xaa\x20\x30"
275 "\x1e\xa0\x03\x02\x01\x01\xa1\x17\x30\x15\x1b\x06\x6b\x72\x62\x74"
276 "\x67\x74\x1b\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45",
277 "KRB-ERROR Test 1"
278 }
279 };
280 int ntests = sizeof(tests) / sizeof(*tests);
281 KRB_ERROR e1;
282 PrincipalName lhaprincipalname = { 1, { 1, lha_principal } };
283 PrincipalName tgtprincipalname = { 1, { 2, nada_tgt_principal } };
284 char *realm = "NADA.KTH.SE";
285
286 e1.pvno = 5;
287 e1.msg_type = 30;
288 e1.ctime = NULL;
289 e1.cusec = NULL;
290 e1.stime = 1069632679;
291 e1.susec = 322981;
292 e1.error_code = 31;
293 e1.crealm = &realm;
294 e1.cname = &lhaprincipalname;
295 e1.realm = "NADA.KTH.SE";
296 e1.sname = tgtprincipalname;
297 e1.e_text = NULL;
298 e1.e_data = NULL;
299
300 tests[0].val = &e1;
301
302 return generic_test (tests, ntests, sizeof(KRB_ERROR),
303 (generic_encode)encode_KRB_ERROR,
304 (generic_length)length_KRB_ERROR,
305 (generic_decode)decode_KRB_ERROR,
306 (generic_free)free_KRB_ERROR,
307 cmp_KRB_ERROR,
308 (generic_copy)copy_KRB_ERROR);
309 }
310
311 static int
312 cmp_Name (void *a, void *b)
313 {
314 Name *aa = a;
315 Name *ab = b;
316
317 COMPARE_INTEGER(aa,ab,element);
318
319 return 0;
320 }
321
322 static int
323 test_Name (void)
324 {
325 struct test_case tests[] = {
326 { NULL, 35,
327 "\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
328 "\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
329 "\x4f\x4c\x4d",
330 "Name CN=Love+L=STOCKHOLM"
331 },
332 { NULL, 35,
333 "\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
334 "\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
335 "\x4f\x4c\x4d",
336 "Name L=STOCKHOLM+CN=Love"
337 }
338 };
339
340 int ntests = sizeof(tests) / sizeof(*tests);
341 Name n1, n2;
342 RelativeDistinguishedName rdn1[1];
343 RelativeDistinguishedName rdn2[1];
344 AttributeTypeAndValue atv1[2];
345 AttributeTypeAndValue atv2[2];
346 unsigned cmp_CN[] = { 2, 5, 4, 3 };
347 unsigned cmp_L[] = { 2, 5, 4, 7 };
348
349 /* n1 */
350 n1.element = choice_Name_rdnSequence;
351 n1.u.rdnSequence.val = rdn1;
352 n1.u.rdnSequence.len = sizeof(rdn1)/sizeof(rdn1[0]);
353 rdn1[0].val = atv1;
354 rdn1[0].len = sizeof(atv1)/sizeof(atv1[0]);
355
356 atv1[0].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
357 atv1[0].type.components = cmp_CN;
358 atv1[0].value.element = choice_DirectoryString_printableString;
359 atv1[0].value.u.printableString.data = "Love";
360 atv1[0].value.u.printableString.length = 4;
361
362 atv1[1].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
363 atv1[1].type.components = cmp_L;
364 atv1[1].value.element = choice_DirectoryString_printableString;
365 atv1[1].value.u.printableString.data = "STOCKHOLM";
366 atv1[1].value.u.printableString.length = 9;
367
368 /* n2 */
369 n2.element = choice_Name_rdnSequence;
370 n2.u.rdnSequence.val = rdn2;
371 n2.u.rdnSequence.len = sizeof(rdn2)/sizeof(rdn2[0]);
372 rdn2[0].val = atv2;
373 rdn2[0].len = sizeof(atv2)/sizeof(atv2[0]);
374
375 atv2[0].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
376 atv2[0].type.components = cmp_L;
377 atv2[0].value.element = choice_DirectoryString_printableString;
378 atv2[0].value.u.printableString.data = "STOCKHOLM";
379 atv2[0].value.u.printableString.length = 9;
380
381 atv2[1].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
382 atv2[1].type.components = cmp_CN;
383 atv2[1].value.element = choice_DirectoryString_printableString;
384 atv2[1].value.u.printableString.data = "Love";
385 atv2[1].value.u.printableString.length = 4;
386
387 /* */
388 tests[0].val = &n1;
389 tests[1].val = &n2;
390
391 return generic_test (tests, ntests, sizeof(Name),
392 (generic_encode)encode_Name,
393 (generic_length)length_Name,
394 (generic_decode)decode_Name,
395 (generic_free)free_Name,
396 cmp_Name,
397 (generic_copy)copy_Name);
398 }
399
400 static int
401 cmp_KeyUsage (void *a, void *b)
402 {
403 KeyUsage *aa = a;
404 KeyUsage *ab = b;
405
406 return KeyUsage2int(*aa) != KeyUsage2int(*ab);
407 }
408
409 static int
410 test_bit_string (void)
411 {
412 struct test_case tests[] = {
413 { NULL, 4,
414 "\x03\x02\x07\x80",
415 "bitstring 1"
416 },
417 { NULL, 4,
418 "\x03\x02\x05\xa0",
419 "bitstring 2"
420 },
421 { NULL, 5,
422 "\x03\x03\x07\x00\x80",
423 "bitstring 3"
424 },
425 { NULL, 3,
426 "\x03\x01\x00",
427 "bitstring 4"
428 }
429 };
430
431 int ntests = sizeof(tests) / sizeof(*tests);
432 KeyUsage ku1, ku2, ku3, ku4;
433
434 memset(&ku1, 0, sizeof(ku1));
435 ku1.digitalSignature = 1;
436 tests[0].val = &ku1;
437
438 memset(&ku2, 0, sizeof(ku2));
439 ku2.digitalSignature = 1;
440 ku2.keyEncipherment = 1;
441 tests[1].val = &ku2;
442
443 memset(&ku3, 0, sizeof(ku3));
444 ku3.decipherOnly = 1;
445 tests[2].val = &ku3;
446
447 memset(&ku4, 0, sizeof(ku4));
448 tests[3].val = &ku4;
449
450
451 return generic_test (tests, ntests, sizeof(KeyUsage),
452 (generic_encode)encode_KeyUsage,
453 (generic_length)length_KeyUsage,
454 (generic_decode)decode_KeyUsage,
455 (generic_free)free_KeyUsage,
456 cmp_KeyUsage,
457 (generic_copy)copy_KeyUsage);
458 }
459
460 static int
461 cmp_TicketFlags (void *a, void *b)
462 {
463 TicketFlags *aa = a;
464 TicketFlags *ab = b;
465
466 return TicketFlags2int(*aa) != TicketFlags2int(*ab);
467 }
468
469 static int
470 test_bit_string_rfc1510 (void)
471 {
472 struct test_case tests[] = {
473 { NULL, 7,
474 "\x03\x05\x00\x80\x00\x00\x00",
475 "TF bitstring 1"
476 },
477 { NULL, 7,
478 "\x03\x05\x00\x40\x20\x00\x00",
479 "TF bitstring 2"
480 },
481 { NULL, 7,
482 "\x03\x05\x00\x00\x20\x00\x00",
483 "TF bitstring 3"
484 },
485 { NULL, 7,
486 "\x03\x05\x00\x00\x00\x00\x00",
487 "TF bitstring 4"
488 }
489 };
490
491 int ntests = sizeof(tests) / sizeof(*tests);
492 TicketFlags tf1, tf2, tf3, tf4;
493
494 memset(&tf1, 0, sizeof(tf1));
495 tf1.reserved = 1;
496 tests[0].val = &tf1;
497
498 memset(&tf2, 0, sizeof(tf2));
499 tf2.forwardable = 1;
500 tf2.pre_authent = 1;
501 tests[1].val = &tf2;
502
503 memset(&tf3, 0, sizeof(tf3));
504 tf3.pre_authent = 1;
505 tests[2].val = &tf3;
506
507 memset(&tf4, 0, sizeof(tf4));
508 tests[3].val = &tf4;
509
510
511 return generic_test (tests, ntests, sizeof(TicketFlags),
512 (generic_encode)encode_TicketFlags,
513 (generic_length)length_TicketFlags,
514 (generic_decode)decode_TicketFlags,
515 (generic_free)free_TicketFlags,
516 cmp_TicketFlags,
517 (generic_copy)copy_TicketFlags);
518 }
519
520 static int
521 cmp_KerberosTime (void *a, void *b)
522 {
523 KerberosTime *aa = a;
524 KerberosTime *ab = b;
525
526 return *aa != *ab;
527 }
528
529 static int
530 test_time (void)
531 {
532 struct test_case tests[] = {
533 { NULL, 17,
534 "\x18\x0f\x31\x39\x37\x30\x30\x31\x30\x31\x30\x31\x31\x38\x33\x31"
535 "\x5a",
536 "time 1" },
537 { NULL, 17,
538 "\x18\x0f\x32\x30\x30\x39\x30\x35\x32\x34\x30\x32\x30\x32\x34\x30"
539 "\x5a",
540 "time 2" }
541 };
542
543 int ntests = sizeof(tests) / sizeof(*tests);
544 KerberosTime times[] = {
545 4711,
546 1243130560
547 };
548
549 tests[0].val = &times[0];
550 tests[1].val = &times[1];
551
552 return generic_test (tests, ntests, sizeof(KerberosTime),
553 (generic_encode)encode_KerberosTime,
554 (generic_length)length_KerberosTime,
555 (generic_decode)decode_KerberosTime,
556 (generic_free)free_KerberosTime,
557 cmp_KerberosTime,
558 (generic_copy)copy_KerberosTime);
559 }
560
561 struct {
562 const char *cert;
563 size_t len;
564 } certs[] = {
565 {
566 "\x30\x82\x02\x6c\x30\x82\x01\xd5\xa0\x03\x02\x01\x02\x02\x09\x00"
567 "\x99\x32\xde\x61\x0e\x40\x19\x8a\x30\x0d\x06\x09\x2a\x86\x48\x86"
568 "\xf7\x0d\x01\x01\x05\x05\x00\x30\x2a\x31\x1b\x30\x19\x06\x03\x55"
569 "\x04\x03\x0c\x12\x68\x78\x35\x30\x39\x20\x54\x65\x73\x74\x20\x52"
570 "\x6f\x6f\x74\x20\x43\x41\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13"
571 "\x02\x53\x45\x30\x1e\x17\x0d\x30\x39\x30\x34\x32\x36\x32\x30\x32"
572 "\x39\x34\x30\x5a\x17\x0d\x31\x39\x30\x34\x32\x34\x32\x30\x32\x39"
573 "\x34\x30\x5a\x30\x2a\x31\x1b\x30\x19\x06\x03\x55\x04\x03\x0c\x12"
574 "\x68\x78\x35\x30\x39\x20\x54\x65\x73\x74\x20\x52\x6f\x6f\x74\x20"
575 "\x43\x41\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x30"
576 "\x81\x9f\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05"
577 "\x00\x03\x81\x8d\x00\x30\x81\x89\x02\x81\x81\x00\xb9\xd3\x1b\x67"
578 "\x1c\xf7\x5e\x26\x81\x3b\x82\xff\x03\xa4\x43\xb5\xb2\x63\x0b\x89"
579 "\x58\x43\xfe\x3d\xe0\x38\x7d\x93\x74\xbb\xad\x21\xa4\x29\xd9\x34"
580 "\x79\xf3\x1c\x8c\x5a\xd6\xb0\xd7\x19\xea\xcc\xaf\xe0\xa8\x40\x02"
581 "\x1d\x91\xf1\xac\x36\xb0\xfb\x08\xbd\xcc\x9a\xe1\xb7\x6e\xee\x0a"
582 "\x69\xbf\x6d\x2b\xee\x20\x82\x61\x06\xf2\x18\xcc\x89\x11\x64\x7e"
583 "\xb2\xff\x47\xd1\x3b\x52\x73\xeb\x5a\xc0\x03\xa6\x4b\xc7\x40\x7e"
584 "\xbc\xe1\x0e\x65\x44\x3f\x40\x8b\x02\x82\x54\x04\xd9\xcc\x2c\x67"
585 "\x01\xb6\x16\x82\xd8\x33\x53\x17\xd7\xde\x8d\x5d\x02\x03\x01\x00"
586 "\x01\xa3\x81\x99\x30\x81\x96\x30\x1d\x06\x03\x55\x1d\x0e\x04\x16"
587 "\x04\x14\x6e\x48\x13\xdc\xbf\x8b\x95\x4c\x13\xf3\x1f\x97\x30\xdd"
588 "\x27\x96\x59\x9b\x0e\x68\x30\x5a\x06\x03\x55\x1d\x23\x04\x53\x30"
589 "\x51\x80\x14\x6e\x48\x13\xdc\xbf\x8b\x95\x4c\x13\xf3\x1f\x97\x30"
590 "\xdd\x27\x96\x59\x9b\x0e\x68\xa1\x2e\xa4\x2c\x30\x2a\x31\x1b\x30"
591 "\x19\x06\x03\x55\x04\x03\x0c\x12\x68\x78\x35\x30\x39\x20\x54\x65"
592 "\x73\x74\x20\x52\x6f\x6f\x74\x20\x43\x41\x31\x0b\x30\x09\x06\x03"
593 "\x55\x04\x06\x13\x02\x53\x45\x82\x09\x00\x99\x32\xde\x61\x0e\x40"
594 "\x19\x8a\x30\x0c\x06\x03\x55\x1d\x13\x04\x05\x30\x03\x01\x01\xff"
595 "\x30\x0b\x06\x03\x55\x1d\x0f\x04\x04\x03\x02\x01\xe6\x30\x0d\x06"
596 "\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x03\x81\x81\x00"
597 "\x52\x9b\xe4\x0e\xee\xc2\x5d\xb7\xf1\xba\x47\xe3\xfe\xaf\x3d\x51"
598 "\x10\xfd\xe8\x0d\x14\x58\x05\x36\xa7\xeb\xd8\x05\xe5\x27\x6f\x51"
599 "\xb8\xec\x90\xd9\x03\xe1\xbc\x9c\x93\x38\x21\x5c\xaf\x4e\x6c\x7b"
600 "\x6c\x65\xa9\x92\xcd\x94\xef\xa8\xae\x90\x12\x14\x78\x2d\xa3\x15"
601 "\xaa\x42\xf1\xd9\x44\x64\x2c\x3c\xc0\xbd\x3a\x48\xd8\x80\x45\x8b"
602 "\xd1\x79\x82\xe0\x0f\xdf\x08\x3c\x60\x21\x6f\x31\x47\x98\xae\x2f"
603 "\xcb\xb1\xa1\xb9\xc1\xa3\x71\x5e\x4a\xc2\x67\xdf\x66\x0a\x51\xb5"
604 "\xad\x60\x05\xdb\x02\xd4\x1a\xd2\xb9\x4e\x01\x08\x2b\xc3\x57\xaf",
605 624 },
606 {
607 "\x30\x82\x02\x54\x30\x82\x01\xbd\xa0\x03\x02\x01\x02\x02\x01\x08"
608 "\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x30"
609 "\x2a\x31\x1b\x30\x19\x06\x03\x55\x04\x03\x0c\x12\x68\x78\x35\x30"
610 "\x39\x20\x54\x65\x73\x74\x20\x52\x6f\x6f\x74\x20\x43\x41\x31\x0b"
611 "\x30\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x30\x1e\x17\x0d\x30"
612 "\x39\x30\x34\x32\x36\x32\x30\x32\x39\x34\x30\x5a\x17\x0d\x31\x39"
613 "\x30\x34\x32\x34\x32\x30\x32\x39\x34\x30\x5a\x30\x1b\x31\x0b\x30"
614 "\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x31\x0c\x30\x0a\x06\x03"
615 "\x55\x04\x03\x0c\x03\x6b\x64\x63\x30\x81\x9f\x30\x0d\x06\x09\x2a"
616 "\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x81\x8d\x00\x30\x81"
617 "\x89\x02\x81\x81\x00\xd2\x41\x7a\xf8\x4b\x55\xb2\xaf\x11\xf9\x43"
618 "\x9b\x43\x81\x09\x3b\x9a\x94\xcf\x00\xf4\x85\x75\x92\xd7\x2a\xa5"
619 "\x11\xf1\xa8\x50\x6e\xc6\x84\x74\x24\x17\xda\x84\xc8\x03\x37\xb2"
620 "\x20\xf3\xba\xb5\x59\x36\x21\x4d\xab\x70\xe2\xc3\x09\x93\x68\x14"
621 "\x12\x79\xc5\xbb\x9e\x1b\x4a\xf0\xc6\x24\x59\x25\xc3\x1c\xa8\x70"
622 "\x66\x5b\x3e\x41\x8e\xe3\x25\x71\x9a\x94\xa0\x5b\x46\x91\x6f\xdd"
623 "\x58\x14\xec\x89\xe5\x8c\x96\xc5\x38\x60\xe4\xab\xf2\x75\xee\x6e"
624 "\x62\xfc\xe1\xbd\x03\x47\xff\xc4\xbe\x0f\xca\x70\x73\xe3\x74\x58"
625 "\x3a\x2f\x04\x2d\x39\x02\x03\x01\x00\x01\xa3\x81\x98\x30\x81\x95"
626 "\x30\x09\x06\x03\x55\x1d\x13\x04\x02\x30\x00\x30\x0b\x06\x03\x55"
627 "\x1d\x0f\x04\x04\x03\x02\x05\xe0\x30\x12\x06\x03\x55\x1d\x25\x04"
628 "\x0b\x30\x09\x06\x07\x2b\x06\x01\x05\x02\x03\x05\x30\x1d\x06\x03"
629 "\x55\x1d\x0e\x04\x16\x04\x14\x3a\xd3\x73\xff\xab\xdb\x7d\x8d\xc6"
630 "\x3a\xa2\x26\x3e\xae\x78\x95\x80\xc9\xe6\x31\x30\x48\x06\x03\x55"
631 "\x1d\x11\x04\x41\x30\x3f\xa0\x3d\x06\x06\x2b\x06\x01\x05\x02\x02"
632 "\xa0\x33\x30\x31\xa0\x0d\x1b\x0b\x54\x45\x53\x54\x2e\x48\x35\x4c"
633 "\x2e\x53\x45\xa1\x20\x30\x1e\xa0\x03\x02\x01\x01\xa1\x17\x30\x15"
634 "\x1b\x06\x6b\x72\x62\x74\x67\x74\x1b\x0b\x54\x45\x53\x54\x2e\x48"
635 "\x35\x4c\x2e\x53\x45\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01"
636 "\x01\x05\x05\x00\x03\x81\x81\x00\x83\xf4\x14\xa7\x6e\x59\xff\x80"
637 "\x64\xe7\xfa\xcf\x13\x80\x86\xe1\xed\x02\x38\xad\x96\x72\x25\xe5"
638 "\x06\x7a\x9a\xbc\x24\x74\xa9\x75\x55\xb2\x49\x80\x69\x45\x95\x4a"
639 "\x4c\x76\xa9\xe3\x4e\x49\xd3\xc2\x69\x5a\x95\x03\xeb\xba\x72\x23"
640 "\x9c\xfd\x3d\x8b\xc6\x07\x82\x3b\xf4\xf3\xef\x6c\x2e\x9e\x0b\xac"
641 "\x9e\x6c\xbb\x37\x4a\xa1\x9e\x73\xd1\xdc\x97\x61\xba\xfc\xd3\x49"
642 "\xa6\xc2\x4c\x55\x2e\x06\x37\x76\xb5\xef\x57\xe7\x57\x58\x8a\x71"
643 "\x63\xf3\xeb\xe7\x55\x68\x0d\xf6\x46\x4c\xfb\xf9\x43\xbb\x0c\x92"
644 "\x4f\x4e\x22\x7b\x63\xe8\x4f\x9c",
645 600
646 }
647 };
648
649 static int
650 test_cert(void)
651 {
652 Certificate c, c2;
653 size_t size;
654 size_t i;
655 int ret;
656
657 for (i = 0; i < sizeof(certs)/sizeof(certs[0]); i++) {
658
659 ret = decode_Certificate((unsigned char *)certs[i].cert,
660 certs[i].len, &c, &size);
661 if (ret)
662 return ret;
663
664 ret = copy_Certificate(&c, &c2);
665 free_Certificate(&c);
666 if (ret)
667 return ret;
668
669 free_Certificate(&c2);
670 }
671
672 return 0;
673 }
674
675 struct {
676 const char *sd;
677 size_t len;
678 } signeddata[] = {
679 {
680 "\x30\x80\x02\x01\x03\x31\x0b\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a"
681 "\x05\x00\x30\x80\x06\x07\x2b\x06\x01\x05\x02\x03\x03\xa0\x80\x24"
682 "\x80\x04\x50\x30\x4e\xa0\x2b\x30\x29\xa0\x03\x02\x01\x12\xa1\x22"
683 "\x04\x20\x78\xf4\x86\x31\xc6\xc2\xc9\xcb\xef\x0c\xd7\x3a\x2a\xcd"
684 "\x8c\x13\x34\x83\xb1\x5c\xa8\xbe\xbf\x2f\xea\xd2\xbb\xd8\x8c\x18"
685 "\x47\x01\xa1\x1f\x30\x1d\xa0\x03\x02\x01\x0c\xa1\x16\x04\x14\xa6"
686 "\x2c\x52\xb2\x80\x98\x30\x40\xbc\x5f\xb0\x77\x2d\x8a\xd7\xa1\xda"
687 "\x3c\xc5\x62\x00\x00\x00\x00\x00\x00\xa0\x82\x02\x09\x30\x82\x02"
688 "\x05\x30\x82\x01\x6e\xa0\x03\x02\x01\x02\x02\x04\x49\x75\x57\xbf"
689 "\x30\x0b\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x30\x3b\x31"
690 "\x1f\x30\x1d\x06\x03\x55\x04\x03\x0c\x16\x63\x6f\x6d\x2e\x61\x70"
691 "\x70\x6c\x65\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73\x2e\x6b\x64\x63"
692 "\x31\x18\x30\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53\x79\x73\x74\x65"
693 "\x6d\x20\x49\x64\x65\x6e\x74\x69\x74\x79\x30\x1e\x17\x0d\x30\x39"
694 "\x31\x32\x30\x34\x30\x30\x32\x30\x32\x34\x5a\x17\x0d\x32\x39\x31"
695 "\x31\x32\x39\x30\x30\x32\x30\x32\x34\x5a\x30\x3b\x31\x1f\x30\x1d"
696 "\x06\x03\x55\x04\x03\x0c\x16\x63\x6f\x6d\x2e\x61\x70\x70\x6c\x65"
697 "\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73\x2e\x6b\x64\x63\x31\x18\x30"
698 "\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53\x79\x73\x74\x65\x6d\x20\x49"
699 "\x64\x65\x6e\x74\x69\x74\x79\x30\x81\x9f\x30\x0d\x06\x09\x2a\x86"
700 "\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x81\x8d\x00\x30\x81\x89"
701 "\x02\x81\x81\x00\xb2\xc5\x4b\x34\xe3\x93\x99\xbb\xaa\xd1\x70\x62"
702 "\x6c\x9c\xcc\xa6\xbc\x47\xc3\x23\xff\x15\xb9\x11\x27\x0a\xf8\x55"
703 "\x4c\xb2\x43\x34\x75\xad\x55\xbb\xb9\x8a\xd0\x25\x64\xa4\x8c\x82"
704 "\x74\x5d\x89\x52\xe2\x76\x75\x08\x67\xb5\x9c\x9c\x69\x86\x0c\x6d"
705 "\x79\xf7\xa0\xbe\x42\x8f\x90\x46\x0c\x18\xf4\x7a\x56\x17\xa4\x65"
706 "\x00\x3a\x5e\x3e\xbf\xbc\xf5\xe2\x2c\x26\x03\x52\xdd\xd4\x85\x3f"
707 "\x03\xd7\x0c\x45\x7f\xff\xdd\x1e\x70\x6c\x9f\xb0\x8c\xd0\x33\xad"
708 "\x92\x54\x17\x9d\x88\x89\x1a\xee\xef\xf7\x96\x3e\x68\xc3\xd1\x60"
709 "\x47\x86\x80\x5d\x02\x03\x01\x00\x01\xa3\x18\x30\x16\x30\x14\x06"
710 "\x03\x55\x1d\x25\x04\x0d\x30\x0b\x06\x09\x2a\x86\x48\x86\xf7\x63"
711 "\x64\x04\x04\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05"
712 "\x05\x00\x03\x81\x81\x00\x9b\xbb\xaa\x63\x66\xd8\x70\x84\x3e\xf6"
713 "\xa1\x3b\xf3\xe6\xd7\x3d\xfc\x4f\xc9\x45\xaa\x31\x43\x8d\xb5\x72"
714 "\xe4\x34\x95\x7b\x6e\x5f\xe5\xc8\x5e\xaf\x12\x08\x6d\xd7\x25\x76"
715 "\x40\xd5\xdc\x83\x7f\x2f\x74\xd1\x63\xc0\x7c\x26\x4d\x53\x10\xe7"
716 "\xfa\xcc\xf2\x60\x41\x63\xdf\x56\xd6\xd9\xc0\xb4\xd0\x73\x99\x54"
717 "\x40\xad\x90\x79\x2d\xd2\x5e\xcb\x13\x22\x2b\xd0\x76\xef\x8a\x48"
718 "\xfd\xb2\x6e\xca\x04\x4e\x91\x3f\xb4\x63\xad\x22\x3a\xf7\x20\x9c"
719 "\x4c\x0e\x47\x78\xe5\x2a\x85\x0e\x90\x7a\xce\x46\xe6\x15\x02\xb0"
720 "\x83\xe7\xac\xfa\x92\xf8\x31\x81\xe8\x30\x81\xe5\x02\x01\x01\x30"
721 "\x43\x30\x3b\x31\x1f\x30\x1d\x06\x03\x55\x04\x03\x0c\x16\x63\x6f"
722 "\x6d\x2e\x61\x70\x70\x6c\x65\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73"
723 "\x2e\x6b\x64\x63\x31\x18\x30\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53"
724 "\x79\x73\x74\x65\x6d\x20\x49\x64\x65\x6e\x74\x69\x74\x79\x02\x04"
725 "\x49\x75\x57\xbf\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x30"
726 "\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x04\x81"
727 "\x80\x50\x2c\x69\xe1\xd2\xc4\xd1\xcc\xdc\xe0\xe9\x8a\x6b\x6a\x97"
728 "\x1b\xb4\xe0\xa8\x20\xbe\x09\x6d\xe1\x55\x5f\x07\x70\x94\x2e\x14"
729 "\xed\x4e\xb1\x69\x75\x40\xbb\x99\x87\xed\x23\x50\x27\x5f\xaa\xc4"
730 "\x84\x60\x06\xfe\x45\xfd\x7e\x1b\x18\xe0\x0b\x77\x35\x2a\xb2\xf2"
731 "\xe0\x88\x31\xad\x82\x31\x4a\xbc\x6d\x71\x62\xe6\x4d\x33\xb4\x09"
732 "\x6e\x3f\x14\x12\xf2\x89\x29\x31\x84\x60\x2b\xa8\x2d\xe6\xca\x2f"
733 "\x03\x3d\xd4\x69\x89\xb3\x98\xfd\xac\x63\x14\xaf\x6a\x52\x2a\xac"
734 "\xe3\x8e\xfa\x21\x41\x8f\xcc\x04\x2d\x52\xee\x49\x54\x0d\x58\x51"
735 "\x77\x00\x00",
736 883
737 }
738 };
739
740 static int
741 test_SignedData(void)
742 {
743 SignedData sd;
744 size_t size, i;
745 int ret;
746
747 for (i = 0; i < sizeof(signeddata) / sizeof(signeddata[0]); i++) {
748
749 ret = decode_SignedData((unsigned char *)signeddata[i].sd,
750 signeddata[i].len, &sd, &size);
751 if (ret)
752 return ret;
753
754 free_SignedData(&sd);
755 }
756
757 return 0;
758 }
759
760
761 static int
762 cmp_TESTLargeTag (void *a, void *b)
763 {
764 TESTLargeTag *aa = a;
765 TESTLargeTag *ab = b;
766
767 COMPARE_INTEGER(aa,ab,foo);
768 COMPARE_INTEGER(aa,ab,bar);
769 return 0;
770 }
771
772 static int
773 test_large_tag (void)
774 {
775 struct test_case tests[] = {
776 { NULL, 15, "\x30\x0d\xbf\x7f\x03\x02\x01\x01\xbf\x81\x00\x03\x02\x01\x02", "large tag 1" }
777 };
778
779 int ntests = sizeof(tests) / sizeof(*tests);
780 TESTLargeTag lt1;
781
782 memset(&lt1, 0, sizeof(lt1));
783 lt1.foo = 1;
784 lt1.bar = 2;
785
786 tests[0].val = &lt1;
787
788 return generic_test (tests, ntests, sizeof(TESTLargeTag),
789 (generic_encode)encode_TESTLargeTag,
790 (generic_length)length_TESTLargeTag,
791 (generic_decode)decode_TESTLargeTag,
792 (generic_free)free_TESTLargeTag,
793 cmp_TESTLargeTag,
794 (generic_copy)copy_TESTLargeTag);
795 }
796
797 struct test_data {
798 int ok;
799 size_t len;
800 size_t expected_len;
801 void *data;
802 };
803
804 static int
805 check_tag_length(void)
806 {
807 struct test_data td[] = {
808 { 1, 3, 3, "\x02\x01\x00"},
809 { 1, 3, 3, "\x02\x01\x7f"},
810 { 1, 4, 4, "\x02\x02\x00\x80"},
811 { 1, 4, 4, "\x02\x02\x01\x00"},
812 { 1, 4, 4, "\x02\x02\x02\x00"},
813 { 0, 3, 0, "\x02\x02\x00"},
814 { 0, 3, 0, "\x02\x7f\x7f"},
815 { 0, 4, 0, "\x02\x03\x00\x80"},
816 { 0, 4, 0, "\x02\x7f\x01\x00"},
817 { 0, 5, 0, "\x02\xff\x7f\x02\x00"}
818 };
819 size_t sz;
820 TESTuint32 values[] = {0, 127, 128, 256, 512,
821 0, 127, 128, 256, 512 };
822 TESTuint32 u;
823 int i, ret, failed = 0;
824 void *buf;
825
826 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
827 struct map_page *page;
828
829 buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
830
831 ret = decode_TESTuint32(buf, td[i].len, &u, &sz);
832 if (ret) {
833 if (td[i].ok) {
834 printf("failed with tag len test %d\n", i);
835 failed = 1;
836 }
837 } else {
838 if (td[i].ok == 0) {
839 printf("failed with success for tag len test %d\n", i);
840 failed = 1;
841 }
842 if (td[i].expected_len != sz) {
843 printf("wrong expected size for tag test %d\n", i);
844 failed = 1;
845 }
846 if (values[i] != u) {
847 printf("wrong value for tag test %d\n", i);
848 failed = 1;
849 }
850 }
851 map_free(page, "test", "decode");
852 }
853 return failed;
854 }
855
856 static int
857 check_tag_length64(void)
858 {
859 struct test_data td[] = {
860 { 1, 3, 3, "\x02\x01\x00"},
861 { 1, 7, 7, "\x02\x05\x01\xff\xff\xff\xff"},
862 { 1, 7, 7, "\x02\x05\x02\x00\x00\x00\x00"},
863 { 1, 9, 9, "\x02\x07\x7f\xff\xff\xff\xff\xff\xff"},
864 { 1, 10, 10, "\x02\x08\x00\x80\x00\x00\x00\x00\x00\x00"},
865 { 1, 10, 10, "\x02\x08\x7f\xff\xff\xff\xff\xff\xff\xff"},
866 { 1, 11, 11, "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"},
867 { 0, 3, 0, "\x02\x02\x00"},
868 { 0, 3, 0, "\x02\x7f\x7f"},
869 { 0, 4, 0, "\x02\x03\x00\x80"},
870 { 0, 4, 0, "\x02\x7f\x01\x00"},
871 { 0, 5, 0, "\x02\xff\x7f\x02\x00"}
872 };
873 size_t sz;
874 TESTuint64 values[] = {0, 8589934591LL, 8589934592LL,
875 36028797018963967LL, 36028797018963968LL,
876 9223372036854775807LL, 18446744073709551615ULL,
877 0, 127, 128, 256, 512 };
878 TESTuint64 u;
879 int i, ret, failed = 0;
880 void *buf;
881
882 if (sizeof(TESTuint64) != sizeof(uint64_t)) {
883 ret += 1;
884 printf("sizeof(TESTuint64) %d != sizeof(uint64_t) %d\n",
885 (int)sizeof(TESTuint64), (int)sizeof(uint64_t));
886 }
887
888 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
889 struct map_page *page;
890
891 buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
892
893 ret = decode_TESTuint64(buf, td[i].len, &u, &sz);
894 if (ret) {
895 if (td[i].ok) {
896 printf("failed with tag len test %d\n", i);
897 printf("ret = %d\n", ret);
898 failed = 1;
899 }
900 } else {
901 if (td[i].ok == 0) {
902 printf("failed with success for tag len test %d\n", i);
903 failed = 1;
904 }
905 if (td[i].expected_len != sz) {
906 printf("wrong expected size for tag test %d\n", i);
907 printf("sz = %lu\n", (unsigned long)sz);
908 failed = 1;
909 }
910 if (values[i] != u) {
911 printf("wrong value for tag test %d\n", i);
912 printf("Expected value: %llu\nActual value: %llu\n",
913 (unsigned long long)values[i], (unsigned long long)u);
914 failed = 1;
915 }
916 }
917 map_free(page, "test", "decode");
918 }
919 return failed;
920 }
921
922 static int
923 check_tag_length64s(void)
924 {
925 struct test_data td[] = {
926 { 1, 3, 3, "\x02\x01\x00"},
927 { 1, 7, 7, "\x02\x05\xfe\x00\x00\x00\x01"},
928 { 1, 7, 7, "\x02\x05\xfe\x00\x00\x00\x00"},
929 { 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x01"},
930 { 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x00"},
931 { 1, 10, 10, "\x02\x08\x80\x00\x00\x00\x00\x00\x00\x01"},
932 { 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x01"},
933 { 0, 3, 0, "\x02\x02\x00"},
934 { 0, 3, 0, "\x02\x7f\x7f"},
935 { 0, 4, 0, "\x02\x03\x00\x80"},
936 { 0, 4, 0, "\x02\x7f\x01\x00"},
937 { 0, 5, 0, "\x02\xff\x7f\x02\x00"}
938 };
939 size_t sz;
940 TESTint64 values[] = {0, -8589934591LL, -8589934592LL,
941 -36028797018963967LL, -36028797018963968LL,
942 -9223372036854775807LL, -36028797018963967LL,
943 0, 127, 128, 256, 512 };
944 TESTint64 u;
945 int i, ret, failed = 0;
946 void *buf;
947
948 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
949 struct map_page *page;
950
951 buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
952
953 ret = decode_TESTint64(buf, td[i].len, &u, &sz);
954 if (ret) {
955 if (td[i].ok) {
956 printf("failed with tag len test %d\n", i);
957 printf("ret = %d\n", ret);
958 failed = 1;
959 }
960 } else {
961 if (td[i].ok == 0) {
962 printf("failed with success for tag len test %d\n", i);
963 failed = 1;
964 }
965 if (td[i].expected_len != sz) {
966 printf("wrong expected size for tag test %d\n", i);
967 printf("sz = %lu\n", (unsigned long)sz);
968 failed = 1;
969 }
970 if (values[i] != u) {
971 printf("wrong value for tag test %d\n", i);
972 printf("Expected value: %lld\nActual value: %lld\n",
973 (long long)values[i], (long long)u);
974 failed = 1;
975 }
976 }
977 map_free(page, "test", "decode");
978 }
979 return failed;
980 }
981
982 static int
983 cmp_TESTChoice (void *a, void *b)
984 {
985 return 0;
986 }
987
988 static int
989 test_choice (void)
990 {
991 struct test_case tests[] = {
992 { NULL, 5, "\xa1\x03\x02\x01\x01", "large choice 1" },
993 { NULL, 5, "\xa2\x03\x02\x01\x02", "large choice 2" }
994 };
995
996 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
997 TESTChoice1 c1;
998 TESTChoice1 c2_1;
999 TESTChoice2 c2_2;
1000
1001 memset(&c1, 0, sizeof(c1));
1002 c1.element = choice_TESTChoice1_i1;
1003 c1.u.i1 = 1;
1004 tests[0].val = &c1;
1005
1006 memset(&c2_1, 0, sizeof(c2_1));
1007 c2_1.element = choice_TESTChoice1_i2;
1008 c2_1.u.i2 = 2;
1009 tests[1].val = &c2_1;
1010
1011 ret += generic_test (tests, ntests, sizeof(TESTChoice1),
1012 (generic_encode)encode_TESTChoice1,
1013 (generic_length)length_TESTChoice1,
1014 (generic_decode)decode_TESTChoice1,
1015 (generic_free)free_TESTChoice1,
1016 cmp_TESTChoice,
1017 (generic_copy)copy_TESTChoice1);
1018
1019 memset(&c2_2, 0, sizeof(c2_2));
1020 c2_2.element = choice_TESTChoice2_asn1_ellipsis;
1021 c2_2.u.asn1_ellipsis.data = "\xa2\x03\x02\x01\x02";
1022 c2_2.u.asn1_ellipsis.length = 5;
1023 tests[1].val = &c2_2;
1024
1025 ret += generic_test (tests, ntests, sizeof(TESTChoice2),
1026 (generic_encode)encode_TESTChoice2,
1027 (generic_length)length_TESTChoice2,
1028 (generic_decode)decode_TESTChoice2,
1029 (generic_free)free_TESTChoice2,
1030 cmp_TESTChoice,
1031 (generic_copy)copy_TESTChoice2);
1032
1033 return ret;
1034 }
1035
1036 #ifdef IMPLICIT_TAGGING_WORKS
1037 static int
1038 cmp_TESTImplicit (void *a, void *b)
1039 {
1040 TESTImplicit *aa = a;
1041 TESTImplicit *ab = b;
1042
1043 COMPARE_INTEGER(aa,ab,ti1);
1044 COMPARE_INTEGER(aa,ab,ti2.foo);
1045 COMPARE_INTEGER(aa,ab,ti3);
1046 return 0;
1047 }
1048 #endif
1049
1050 /*
1051 UNIV CONS Sequence 14
1052 CONTEXT PRIM 0 1 00
1053 CONTEXT CONS 1 6
1054 CONTEXT CONS 127 3
1055 UNIV PRIM Integer 1 02
1056 CONTEXT PRIM 2 1 03
1057 */
1058
1059 static int
1060 test_implicit (void)
1061 {
1062 int ret = 0;
1063 #ifdef IMPLICIT_TAGGING_WORKS
1064 struct test_case tests[] = {
1065 { NULL, 18,
1066 "\x30\x10\x80\x01\x00\xa1\x06\xbf"
1067 "\x7f\x03\x02\x01\x02\xa2\x03\x84\x01\x03",
1068 "implicit 1" }
1069 };
1070
1071 int ntests = sizeof(tests) / sizeof(*tests);
1072 TESTImplicit c0;
1073
1074 memset(&c0, 0, sizeof(c0));
1075 c0.ti1 = 0;
1076 c0.ti2.foo = 2;
1077 c0.ti3 = 3;
1078 tests[0].val = &c0;
1079
1080 ret += generic_test (tests, ntests, sizeof(TESTImplicit),
1081 (generic_encode)encode_TESTImplicit,
1082 (generic_length)length_TESTImplicit,
1083 (generic_decode)decode_TESTImplicit,
1084 (generic_free)free_TESTImplicit,
1085 cmp_TESTImplicit,
1086 (generic_copy)copy_TESTImplicit);
1087
1088 ret += generic_test (tests, ntests, sizeof(TESTImplicit2),
1089 (generic_encode)encode_TESTImplicit2,
1090 (generic_length)length_TESTImplicit2,
1091 (generic_decode)decode_TESTImplicit2,
1092 (generic_free)free_TESTImplicit2,
1093 cmp_TESTImplicit,
1094 NULL);
1095
1096 #endif /* IMPLICIT_TAGGING_WORKS */
1097 return ret;
1098 }
1099
1100 static int
1101 cmp_TESTAlloc (void *a, void *b)
1102 {
1103 TESTAlloc *aa = a;
1104 TESTAlloc *ab = b;
1105
1106 IF_OPT_COMPARE(aa,ab,tagless) {
1107 COMPARE_INTEGER(aa,ab,tagless->ai);
1108 }
1109
1110 COMPARE_INTEGER(aa,ab,three);
1111
1112 IF_OPT_COMPARE(aa,ab,tagless2) {
1113 COMPARE_OPT_OCTECT_STRING(aa, ab, tagless2);
1114 }
1115
1116 return 0;
1117 }
1118
1119 /*
1120 UNIV CONS Sequence 12
1121 UNIV CONS Sequence 5
1122 CONTEXT CONS 0 3
1123 UNIV PRIM Integer 1 01
1124 CONTEXT CONS 1 3
1125 UNIV PRIM Integer 1 03
1126
1127 UNIV CONS Sequence 5
1128 CONTEXT CONS 1 3
1129 UNIV PRIM Integer 1 03
1130
1131 UNIV CONS Sequence 8
1132 CONTEXT CONS 1 3
1133 UNIV PRIM Integer 1 04
1134 UNIV PRIM Integer 1 05
1135
1136 */
1137
1138 static int
1139 test_taglessalloc (void)
1140 {
1141 struct test_case tests[] = {
1142 { NULL, 14,
1143 "\x30\x0c\x30\x05\xa0\x03\x02\x01\x01\xa1\x03\x02\x01\x03",
1144 "alloc 1" },
1145 { NULL, 7,
1146 "\x30\x05\xa1\x03\x02\x01\x03",
1147 "alloc 2" },
1148 { NULL, 10,
1149 "\x30\x08\xa1\x03\x02\x01\x04\x02\x01\x05",
1150 "alloc 3" }
1151 };
1152
1153 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
1154 TESTAlloc c1, c2, c3;
1155 heim_any any3;
1156
1157 memset(&c1, 0, sizeof(c1));
1158 c1.tagless = ecalloc(1, sizeof(*c1.tagless));
1159 c1.tagless->ai = 1;
1160 c1.three = 3;
1161 tests[0].val = &c1;
1162
1163 memset(&c2, 0, sizeof(c2));
1164 c2.tagless = NULL;
1165 c2.three = 3;
1166 tests[1].val = &c2;
1167
1168 memset(&c3, 0, sizeof(c3));
1169 c3.tagless = NULL;
1170 c3.three = 4;
1171 c3.tagless2 = &any3;
1172 any3.data = "\x02\x01\x05";
1173 any3.length = 3;
1174 tests[2].val = &c3;
1175
1176 ret += generic_test (tests, ntests, sizeof(TESTAlloc),
1177 (generic_encode)encode_TESTAlloc,
1178 (generic_length)length_TESTAlloc,
1179 (generic_decode)decode_TESTAlloc,
1180 (generic_free)free_TESTAlloc,
1181 cmp_TESTAlloc,
1182 (generic_copy)copy_TESTAlloc);
1183
1184 free(c1.tagless);
1185
1186 return ret;
1187 }
1188
1189 static int
1190 cmp_TESTOptional (void *a, void *b)
1191 {
1192 TESTOptional *aa = a;
1193 TESTOptional *ab = b;
1194
1195 IF_OPT_COMPARE(aa,ab,zero) {
1196 COMPARE_OPT_INTEGER(aa,ab,zero);
1197 }
1198 IF_OPT_COMPARE(aa,ab,one) {
1199 COMPARE_OPT_INTEGER(aa,ab,one);
1200 }
1201 return 0;
1202 }
1203
1204 /*
1205 UNIV CONS Sequence 5
1206 CONTEXT CONS 0 3
1207 UNIV PRIM Integer 1 00
1208
1209 UNIV CONS Sequence 5
1210 CONTEXT CONS 1 3
1211 UNIV PRIM Integer 1 03
1212
1213 UNIV CONS Sequence 10
1214 CONTEXT CONS 0 3
1215 UNIV PRIM Integer 1 00
1216 CONTEXT CONS 1 3
1217 UNIV PRIM Integer 1 01
1218
1219 */
1220
1221 static int
1222 test_optional (void)
1223 {
1224 struct test_case tests[] = {
1225 { NULL, 2,
1226 "\x30\x00",
1227 "optional 0" },
1228 { NULL, 7,
1229 "\x30\x05\xa0\x03\x02\x01\x00",
1230 "optional 1" },
1231 { NULL, 7,
1232 "\x30\x05\xa1\x03\x02\x01\x01",
1233 "optional 2" },
1234 { NULL, 12,
1235 "\x30\x0a\xa0\x03\x02\x01\x00\xa1\x03\x02\x01\x01",
1236 "optional 3" }
1237 };
1238
1239 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
1240 TESTOptional c0, c1, c2, c3;
1241 int zero = 0;
1242 int one = 1;
1243
1244 c0.zero = NULL;
1245 c0.one = NULL;
1246 tests[0].val = &c0;
1247
1248 c1.zero = &zero;
1249 c1.one = NULL;
1250 tests[1].val = &c1;
1251
1252 c2.zero = NULL;
1253 c2.one = &one;
1254 tests[2].val = &c2;
1255
1256 c3.zero = &zero;
1257 c3.one = &one;
1258 tests[3].val = &c3;
1259
1260 ret += generic_test (tests, ntests, sizeof(TESTOptional),
1261 (generic_encode)encode_TESTOptional,
1262 (generic_length)length_TESTOptional,
1263 (generic_decode)decode_TESTOptional,
1264 (generic_free)free_TESTOptional,
1265 cmp_TESTOptional,
1266 (generic_copy)copy_TESTOptional);
1267
1268 return ret;
1269 }
1270
1271 static int
1272 check_fail_largetag(void)
1273 {
1274 struct test_case tests[] = {
1275 {NULL, 14, "\x30\x0c\xbf\x87\xff\xff\xff\xff\xff\x7f\x03\x02\x01\x01",
1276 "tag overflow"},
1277 {NULL, 0, "", "empty buffer"},
1278 {NULL, 7, "\x30\x05\xa1\x03\x02\x02\x01",
1279 "one too short" },
1280 {NULL, 7, "\x30\x04\xa1\x03\x02\x02\x01",
1281 "two too short" },
1282 {NULL, 7, "\x30\x03\xa1\x03\x02\x02\x01",
1283 "three too short" },
1284 {NULL, 7, "\x30\x02\xa1\x03\x02\x02\x01",
1285 "four too short" },
1286 {NULL, 7, "\x30\x01\xa1\x03\x02\x02\x01",
1287 "five too short" },
1288 {NULL, 7, "\x30\x00\xa1\x03\x02\x02\x01",
1289 "six too short" },
1290 {NULL, 7, "\x30\x05\xa1\x04\x02\x02\x01",
1291 "inner one too long" },
1292 {NULL, 7, "\x30\x00\xa1\x02\x02\x02\x01",
1293 "inner one too short" },
1294 {NULL, 8, "\x30\x05\xbf\x7f\x03\x02\x02\x01",
1295 "inner one too short"},
1296 {NULL, 8, "\x30\x06\xbf\x64\x03\x02\x01\x01",
1297 "wrong tag"},
1298 {NULL, 10, "\x30\x08\xbf\x9a\x9b\x38\x03\x02\x01\x01",
1299 "still wrong tag"}
1300 };
1301 int ntests = sizeof(tests) / sizeof(*tests);
1302
1303 return generic_decode_fail(tests, ntests, sizeof(TESTLargeTag),
1304 (generic_decode)decode_TESTLargeTag);
1305 }
1306
1307
1308 static int
1309 check_fail_sequence(void)
1310 {
1311 struct test_case tests[] = {
1312 {NULL, 0, "", "empty buffer"},
1313 {NULL, 24,
1314 "\x30\x16\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
1315 "\x02\x01\x01\xa2\x03\x02\x01\x01",
1316 "missing one byte from the end, internal length ok"},
1317 {NULL, 25,
1318 "\x30\x18\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
1319 "\x02\x01\x01\xa2\x03\x02\x01\x01",
1320 "inner length one byte too long"},
1321 {NULL, 24,
1322 "\x30\x17\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01"
1323 "\x01\x02\x01\x01\xa2\x03\x02\x01\x01",
1324 "correct buffer but missing one too short"}
1325 };
1326 int ntests = sizeof(tests) / sizeof(*tests);
1327
1328 return generic_decode_fail(tests, ntests, sizeof(TESTSeq),
1329 (generic_decode)decode_TESTSeq);
1330 }
1331
1332 static int
1333 check_fail_choice(void)
1334 {
1335 struct test_case tests[] = {
1336 {NULL, 6,
1337 "\xa1\x02\x02\x01\x01",
1338 "choice one too short"},
1339 {NULL, 6,
1340 "\xa1\x03\x02\x02\x01",
1341 "choice one too short inner"}
1342 };
1343 int ntests = sizeof(tests) / sizeof(*tests);
1344
1345 return generic_decode_fail(tests, ntests, sizeof(TESTChoice1),
1346 (generic_decode)decode_TESTChoice1);
1347 }
1348
1349 static int
1350 check_fail_Ticket(void)
1351 {
1352 char buf[100];
1353 size_t i;
1354 int ret;
1355 struct test_case test;
1356 Ticket ticket;
1357
1358 for (i = 0; i < sizeof(buf); i++) {
1359 memset(buf, 0, sizeof(buf));
1360 memset(&ticket, 0, sizeof(ticket));
1361 test.val = &ticket;
1362 test.byte_len = i;
1363 test.bytes = buf;
1364 test.name = "zero life";
1365 ret = generic_decode_fail(&test, 1, sizeof(Ticket),
1366 (generic_decode)decode_Ticket);
1367 if (ret)
1368 return ret;
1369 }
1370 return 0;
1371 }
1372
1373 static int
1374 check_seq(void)
1375 {
1376 TESTSeqOf seq;
1377 TESTInteger i;
1378 int ret;
1379
1380 seq.val = NULL;
1381 seq.len = 0;
1382
1383 ret = add_TESTSeqOf(&seq, &i);
1384 if (ret) { printf("failed adding\n"); goto out; }
1385 ret = add_TESTSeqOf(&seq, &i);
1386 if (ret) { printf("failed adding\n"); goto out; }
1387 ret = add_TESTSeqOf(&seq, &i);
1388 if (ret) { printf("failed adding\n"); goto out; }
1389 ret = add_TESTSeqOf(&seq, &i);
1390 if (ret) { printf("failed adding\n"); goto out; }
1391
1392 ret = remove_TESTSeqOf(&seq, seq.len - 1);
1393 if (ret) { printf("failed removing\n"); goto out; }
1394 ret = remove_TESTSeqOf(&seq, 2);
1395 if (ret) { printf("failed removing\n"); goto out; }
1396 ret = remove_TESTSeqOf(&seq, 0);
1397 if (ret) { printf("failed removing\n"); goto out; }
1398 ret = remove_TESTSeqOf(&seq, 0);
1399 if (ret) { printf("failed removing\n"); goto out; }
1400 ret = remove_TESTSeqOf(&seq, 0);
1401 if (ret == 0) {
1402 printf("can remove from empty list");
1403 return 1;
1404 }
1405
1406 if (seq.len != 0) {
1407 printf("seq not empty!");
1408 return 1;
1409 }
1410 free_TESTSeqOf(&seq);
1411 ret = 0;
1412
1413 out:
1414
1415 return ret;
1416 }
1417
1418 #define test_seq_of(type, ok, ptr) \
1419 { \
1420 heim_octet_string os; \
1421 size_t size; \
1422 type decode; \
1423 ASN1_MALLOC_ENCODE(type, os.data, os.length, ptr, &size, ret); \
1424 if (ret) \
1425 return ret; \
1426 if (os.length != size) \
1427 abort(); \
1428 ret = decode_##type(os.data, os.length, &decode, &size); \
1429 free(os.data); \
1430 if (ret) { \
1431 if (ok) \
1432 return 1; \
1433 } else { \
1434 free_##type(&decode); \
1435 if (!ok) \
1436 return 1; \
1437 if (size != 0) \
1438 return 1; \
1439 } \
1440 return 0; \
1441 }
1442
1443 static int
1444 check_seq_of_size(void)
1445 {
1446 #if 0 /* template */
1447 TESTInteger integers[4] = { 1, 2, 3, 4 };
1448 int ret;
1449
1450 {
1451 TESTSeqSizeOf1 ssof1f1 = { 1, integers };
1452 TESTSeqSizeOf1 ssof1ok1 = { 2, integers };
1453 TESTSeqSizeOf1 ssof1f2 = { 3, integers };
1454
1455 test_seq_of(TESTSeqSizeOf1, 0, &ssof1f1);
1456 test_seq_of(TESTSeqSizeOf1, 1, &ssof1ok1);
1457 test_seq_of(TESTSeqSizeOf1, 0, &ssof1f2);
1458 }
1459 {
1460 TESTSeqSizeOf2 ssof2f1 = { 0, NULL };
1461 TESTSeqSizeOf2 ssof2ok1 = { 1, integers };
1462 TESTSeqSizeOf2 ssof2ok2 = { 2, integers };
1463 TESTSeqSizeOf2 ssof2f2 = { 3, integers };
1464
1465 test_seq_of(TESTSeqSizeOf2, 0, &ssof2f1);
1466 test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok1);
1467 test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok2);
1468 test_seq_of(TESTSeqSizeOf2, 0, &ssof2f2);
1469 }
1470 {
1471 TESTSeqSizeOf3 ssof3f1 = { 0, NULL };
1472 TESTSeqSizeOf3 ssof3ok1 = { 1, integers };
1473 TESTSeqSizeOf3 ssof3ok2 = { 2, integers };
1474
1475 test_seq_of(TESTSeqSizeOf3, 0, &ssof3f1);
1476 test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok1);
1477 test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok2);
1478 }
1479 {
1480 TESTSeqSizeOf4 ssof4ok1 = { 0, NULL };
1481 TESTSeqSizeOf4 ssof4ok2 = { 1, integers };
1482 TESTSeqSizeOf4 ssof4ok3 = { 2, integers };
1483 TESTSeqSizeOf4 ssof4f1 = { 3, integers };
1484
1485 test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok1);
1486 test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok2);
1487 test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok3);
1488 test_seq_of(TESTSeqSizeOf4, 0, &ssof4f1);
1489 }
1490 #endif
1491 return 0;
1492 }
1493
1494 static int
1495 check_TESTMechTypeList(void)
1496 {
1497 TESTMechTypeList tl;
1498 unsigned oid1[] = { 1, 2, 840, 48018, 1, 2, 2};
1499 unsigned oid2[] = { 1, 2, 840, 113554, 1, 2, 2};
1500 unsigned oid3[] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 30};
1501 unsigned oid4[] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10};
1502 TESTMechType array[] = {{ 7, oid1 },
1503 { 7, oid2 },
1504 { 10, oid3 },
1505 { 10, oid4 }};
1506 size_t size, len;
1507 void *ptr;
1508 int ret;
1509
1510 tl.len = 4;
1511 tl.val = array;
1512
1513 ASN1_MALLOC_ENCODE(TESTMechTypeList, ptr, len, &tl, &size, ret);
1514 if (ret)
1515 errx(1, "TESTMechTypeList: %d", ret);
1516 if (len != size)
1517 abort();
1518 return 0;
1519 }
1520
1521 #ifdef IMPLICIT_TAGGING_WORKS
1522 static int
1523 cmp_TESTSeqOf4(void *a, void *b)
1524 {
1525 TESTSeqOf4 *aa = a;
1526 TESTSeqOf4 *ab = b;
1527 int i;
1528
1529 IF_OPT_COMPARE(aa, ab, b1) {
1530 COMPARE_INTEGER(aa->b1, ab->b1, len);
1531 for (i = 0; i < aa->b1->len; ++i) {
1532 COMPARE_INTEGER(aa->b1->val+i, ab->b1->val+i, u1);
1533 COMPARE_INTEGER(aa->b1->val+i, ab->b1->val+i, u2);
1534 COMPARE_OCTECT_STRING(aa->b1->val+i, ab->b1->val+i, s1);
1535 COMPARE_OCTECT_STRING(aa->b1->val+i, ab->b1->val+i, s2);
1536 }
1537 }
1538 IF_OPT_COMPARE(aa, ab, b2) {
1539 COMPARE_INTEGER(aa->b2, ab->b2, len);
1540 for (i = 0; i < aa->b2->len; ++i) {
1541 COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u1);
1542 COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u2);
1543 COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u3);
1544 COMPARE_OCTECT_STRING(aa->b2->val+i, ab->b2->val+i, s1);
1545 COMPARE_OCTECT_STRING(aa->b2->val+i, ab->b2->val+i, s2);
1546 COMPARE_OCTECT_STRING(aa->b2->val+i, ab->b2->val+i, s3);
1547 }
1548 }
1549 IF_OPT_COMPARE(aa, ab, b3) {
1550 COMPARE_INTEGER(aa->b3, ab->b3, len);
1551 for (i = 0; i < aa->b3->len; ++i) {
1552 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u1);
1553 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u2);
1554 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u3);
1555 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u4);
1556 COMPARE_OCTECT_STRING(aa->b3->val+i, ab->b3->val+i, s1);
1557 COMPARE_OCTECT_STRING(aa->b3->val+i, ab->b3->val+i, s2);
1558 COMPARE_OCTECT_STRING(aa->b3->val+i, ab->b3->val+i, s3);
1559 COMPARE_OCTECT_STRING(aa->b3->val+i, ab->b3->val+i, s4);
1560 }
1561 }
1562 return 0;
1563 }
1564 #endif /* IMPLICIT_TAGGING_WORKS */
1565
1566 static int
1567 test_seq4 (void)
1568 {
1569 int ret = 0;
1570 #ifdef IMPLICIT_TAGGING_WORKS
1571 struct test_case tests[] = {
1572 { NULL, 2,
1573 "\x30\x00",
1574 "seq4 0" },
1575 { NULL, 4,
1576 "\x30\x02" "\xa1\x00",
1577 "seq4 1" },
1578 { NULL, 8,
1579 "\x30\x06" "\xa0\x02\x30\x00" "\xa1\x00",
1580 "seq4 2" },
1581 { NULL, 2 + (2 + 0x18) + (2 + 0x27) + (2 + 0x31),
1582 "\x30\x76" /* 2 SEQ */
1583 "\xa0\x18\x30\x16" /* 4 [0] SEQ */
1584 "\x30\x14" /* 2 SEQ */
1585 "\x04\x00" /* 2 OCTET-STRING */
1586 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
1587 "\x02\x01\x01" /* 3 INT */
1588 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
1589 /* 11 INT */
1590 "\xa1\x27" /* 2 [1] IMPL SEQ */
1591 "\x30\x25" /* 2 SEQ */
1592 "\x02\x01\x01" /* 3 INT */
1593 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
1594 /* 11 INT */
1595 "\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
1596 /* 11 INT */
1597 "\x04\x00" /* 2 OCTET-STRING */
1598 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
1599 "\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
1600 "\xa2\x31" /* 2 [2] IMPL SEQ */
1601 "\x30\x2f" /* 2 SEQ */
1602 "\x04\x00" /* 2 OCTET-STRING */
1603 "\x02\x01\x01" /* 3 INT */
1604 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
1605 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
1606 /* 11 INT */
1607 "\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
1608 "\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
1609 /* 11 INT */
1610 "\x04\x01\x00" /* 3 OCTET-STRING */
1611 "\x02\x05\x01\x00\x00\x00\x00", /* 7 INT */
1612 "seq4 3" },
1613 };
1614
1615 int ntests = sizeof(tests) / sizeof(*tests);
1616 TESTSeqOf4 c[4];
1617 struct TESTSeqOf4_b1 b1[4];
1618 struct TESTSeqOf4_b2 b2[4];
1619 struct TESTSeqOf4_b3 b3[4];
1620 struct TESTSeqOf4_b1_val b1val[4];
1621 struct TESTSeqOf4_b2_val b2val[4];
1622 struct TESTSeqOf4_b3_val b3val[4];
1623
1624 c[0].b1 = NULL;
1625 c[0].b2 = NULL;
1626 c[0].b3 = NULL;
1627 tests[0].val = &c[0];
1628
1629 b2[1].len = 0;
1630 b2[1].val = NULL;
1631 c[1].b1 = NULL;
1632 c[1].b2 = &b2[1];
1633 c[1].b3 = NULL;
1634 tests[1].val = &c[1];
1635
1636 b1[2].len = 0;
1637 b1[2].val = NULL;
1638 b2[2].len = 0;
1639 b2[2].val = NULL;
1640 c[2].b1 = &b1[2];
1641 c[2].b2 = &b2[2];
1642 c[2].b3 = NULL;
1643 tests[2].val = &c[2];
1644
1645 b1val[3].s1.data = "";
1646 b1val[3].s1.length = 0;
1647 b1val[3].u1 = 1LL;
1648 b1val[3].s2.data = "\x01\x02";
1649 b1val[3].s2.length = 2;
1650 b1val[3].u2 = -1LL;
1651
1652 b2val[3].s1.data = "";
1653 b2val[3].s1.length = 0;
1654 b2val[3].u1 = 1LL;
1655 b2val[3].s2.data = "\x01\x02";
1656 b2val[3].s2.length = 2;
1657 b2val[3].u2 = -1LL;
1658 b2val[3].s3.data = "\x00\x01\x02\x03";
1659 b2val[3].s3.length = 4;
1660 b2val[3].u3 = 1LL<<63;
1661
1662 b3val[3].s1.data = "";
1663 b3val[3].s1.length = 0;
1664 b3val[3].u1 = 1LL;
1665 b3val[3].s2.data = "\x01\x02";
1666 b3val[3].s2.length = 2;
1667 b3val[3].u2 = -1LL;
1668 b3val[3].s3.data = "\x00\x01\x02\x03";
1669 b3val[3].s3.length = 4;
1670 b3val[3].u3 = 1LL<<63;
1671 b3val[3].s4.data = "\x00";
1672 b3val[3].s4.length = 1;
1673 b3val[3].u4 = 1LL<<32;
1674
1675 b1[3].len = 1;
1676 b1[3].val = &b1val[3];
1677 b2[3].len = 1;
1678 b2[3].val = &b2val[3];
1679 b3[3].len = 1;
1680 b3[3].val = &b3val[3];
1681 c[3].b1 = &b1[3];
1682 c[3].b2 = &b2[3];
1683 c[3].b3 = &b3[3];
1684 tests[3].val = &c[3];
1685
1686 ret += generic_test (tests, ntests, sizeof(TESTSeqOf4),
1687 (generic_encode)encode_TESTSeqOf4,
1688 (generic_length)length_TESTSeqOf4,
1689 (generic_decode)decode_TESTSeqOf4,
1690 (generic_free)free_TESTSeqOf4,
1691 cmp_TESTSeqOf4,
1692 (generic_copy)copy_TESTSeqOf4);
1693 #endif /* IMPLICIT_TAGGING_WORKS */
1694 return ret;
1695 }
1696
1697 int
1698 main(int argc, char **argv)
1699 {
1700 int ret = 0;
1701
1702 ret += test_principal ();
1703 ret += test_authenticator();
1704 ret += test_krb_error();
1705 ret += test_Name();
1706 ret += test_bit_string();
1707 ret += test_bit_string_rfc1510();
1708 ret += test_time();
1709 ret += test_cert();
1710
1711 ret += check_tag_length();
1712 ret += check_tag_length64();
1713 ret += check_tag_length64s();
1714 ret += test_large_tag();
1715 ret += test_choice();
1716
1717 ret += test_implicit();
1718
1719 ret += test_taglessalloc();
1720 ret += test_optional();
1721
1722 ret += check_fail_largetag();
1723 ret += check_fail_sequence();
1724 ret += check_fail_choice();
1725 ret += check_fail_Ticket();
1726
1727 ret += check_seq();
1728 ret += check_seq_of_size();
1729 ret += test_SignedData();
1730
1731 ret += check_TESTMechTypeList();
1732 ret += test_seq4();
1733
1734 return ret;
1735 }
Heimdal