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