?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:torture: Adapt KDC canon test to Heimdal upstream changes
[Samba.git] / source4 / heimdal / lib / asn1 / check-gen.c
blobf49f5e8edf92b423c1bc51394decd8fef932a8d8
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 <x690sample_asn1.h>
49 #include <test_asn1.h>
50 #include <cms_asn1.h>
51
52 #include "check-common.h"
53
54 static char *lha_principal[] = { "lha" };
55 static char *lharoot_princ[] = { "lha", "root" };
56 static char *datan_princ[] = { "host", "nutcracker.e.kth.se" };
57 static char *nada_tgt_principal[] = { "krbtgt", "NADA.KTH.SE" };
58
59 static int
60 cmp_principal (void *a, void *b)
61 {
62 Principal *pa = a;
63 Principal *pb = b;
64 int i;
65
66 COMPARE_STRING(pa,pb,realm);
67 COMPARE_INTEGER(pa,pb,name.name_type);
68 COMPARE_INTEGER(pa,pb,name.name_string.len);
69
70 for (i = 0; i < pa->name.name_string.len; i++)
71 COMPARE_STRING(pa,pb,name.name_string.val[i]);
72
73 return 0;
74 }
75
76 static int
77 test_principal (void)
78 {
79
80 struct test_case tests[] = {
81 { NULL, 29,
82 "\x30\x1b\xa0\x10\x30\x0e\xa0\x03\x02\x01\x01\xa1\x07\x30\x05\x1b"
83 "\x03\x6c\x68\x61\xa1\x07\x1b\x05\x53\x55\x2e\x53\x45",
84 NULL
85 },
86 { NULL, 35,
87 "\x30\x21\xa0\x16\x30\x14\xa0\x03\x02\x01\x01\xa1\x0d\x30\x0b\x1b"
88 "\x03\x6c\x68\x61\x1b\x04\x72\x6f\x6f\x74\xa1\x07\x1b\x05\x53\x55"
89 "\x2e\x53\x45",
90 NULL
91 },
92 { NULL, 54,
93 "\x30\x34\xa0\x26\x30\x24\xa0\x03\x02\x01\x03\xa1\x1d\x30\x1b\x1b"
94 "\x04\x68\x6f\x73\x74\x1b\x13\x6e\x75\x74\x63\x72\x61\x63\x6b\x65"
95 "\x72\x2e\x65\x2e\x6b\x74\x68\x2e\x73\x65\xa1\x0a\x1b\x08\x45\x2e"
96 "\x4b\x54\x48\x2e\x53\x45",
97 NULL
98 }
99 };
100
101
102 Principal values[] = {
103 { { KRB5_NT_PRINCIPAL, { 1, lha_principal } }, "SU.SE", NULL },
104 { { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } }, "SU.SE", NULL },
105 { { KRB5_NT_SRV_HST, { 2, datan_princ } }, "E.KTH.SE", NULL }
106 };
107 int i, ret;
108 int ntests = sizeof(tests) / sizeof(*tests);
109
110 for (i = 0; i < ntests; ++i) {
111 tests[i].val = &values[i];
112 if (asprintf (&tests[i].name, "Principal %d", i) < 0)
113 errx(1, "malloc");
114 if (tests[i].name == NULL)
115 errx(1, "malloc");
116 }
117
118 ret = generic_test (tests, ntests, sizeof(Principal),
119 (generic_encode)encode_Principal,
120 (generic_length)length_Principal,
121 (generic_decode)decode_Principal,
122 (generic_free)free_Principal,
123 cmp_principal,
124 NULL);
125 for (i = 0; i < ntests; ++i)
126 free (tests[i].name);
127
128 return ret;
129 }
130
131 static int
132 cmp_authenticator (void *a, void *b)
133 {
134 Authenticator *aa = a;
135 Authenticator *ab = b;
136 int i;
137
138 COMPARE_INTEGER(aa,ab,authenticator_vno);
139 COMPARE_STRING(aa,ab,crealm);
140
141 COMPARE_INTEGER(aa,ab,cname.name_type);
142 COMPARE_INTEGER(aa,ab,cname.name_string.len);
143
144 for (i = 0; i < aa->cname.name_string.len; i++)
145 COMPARE_STRING(aa,ab,cname.name_string.val[i]);
146
147 return 0;
148 }
149
150 static int
151 test_authenticator (void)
152 {
153 struct test_case tests[] = {
154 { NULL, 63,
155 "\x62\x3d\x30\x3b\xa0\x03\x02\x01\x05\xa1\x0a\x1b\x08"
156 "\x45\x2e\x4b\x54\x48\x2e\x53\x45\xa2\x10\x30\x0e\xa0"
157 "\x03\x02\x01\x01\xa1\x07\x30\x05\x1b\x03\x6c\x68\x61"
158 "\xa4\x03\x02\x01\x0a\xa5\x11\x18\x0f\x31\x39\x37\x30"
159 "\x30\x31\x30\x31\x30\x30\x30\x31\x33\x39\x5a",
160 NULL
161 },
162 { NULL, 67,
163 "\x62\x41\x30\x3f\xa0\x03\x02\x01\x05\xa1\x07\x1b\x05"
164 "\x53\x55\x2e\x53\x45\xa2\x16\x30\x14\xa0\x03\x02\x01"
165 "\x01\xa1\x0d\x30\x0b\x1b\x03\x6c\x68\x61\x1b\x04\x72"
166 "\x6f\x6f\x74\xa4\x04\x02\x02\x01\x24\xa5\x11\x18\x0f"
167 "\x31\x39\x37\x30\x30\x31\x30\x31\x30\x30\x31\x36\x33"
168 "\x39\x5a",
169 NULL
170 }
171 };
172
173 Authenticator values[] = {
174 { 5, "E.KTH.SE", { KRB5_NT_PRINCIPAL, { 1, lha_principal } },
175 NULL, 10, 99, NULL, NULL, NULL },
176 { 5, "SU.SE", { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } },
177 NULL, 292, 999, NULL, NULL, NULL }
178 };
179 int i, ret;
180 int ntests = sizeof(tests) / sizeof(*tests);
181
182 for (i = 0; i < ntests; ++i) {
183 tests[i].val = &values[i];
184 if (asprintf (&tests[i].name, "Authenticator %d", i) < 0)
185 errx(1, "malloc");
186 if (tests[i].name == NULL)
187 errx(1, "malloc");
188 }
189
190 ret = generic_test (tests, ntests, sizeof(Authenticator),
191 (generic_encode)encode_Authenticator,
192 (generic_length)length_Authenticator,
193 (generic_decode)decode_Authenticator,
194 (generic_free)free_Authenticator,
195 cmp_authenticator,
196 (generic_copy)copy_Authenticator);
197 for (i = 0; i < ntests; ++i)
198 free(tests[i].name);
199
200 return ret;
201 }
202
203 static int
204 cmp_KRB_ERROR (void *a, void *b)
205 {
206 KRB_ERROR *aa = a;
207 KRB_ERROR *ab = b;
208 int i;
209
210 COMPARE_INTEGER(aa,ab,pvno);
211 COMPARE_INTEGER(aa,ab,msg_type);
212
213 IF_OPT_COMPARE(aa,ab,ctime) {
214 COMPARE_INTEGER(aa,ab,ctime);
215 }
216 IF_OPT_COMPARE(aa,ab,cusec) {
217 COMPARE_INTEGER(aa,ab,cusec);
218 }
219 COMPARE_INTEGER(aa,ab,stime);
220 COMPARE_INTEGER(aa,ab,susec);
221 COMPARE_INTEGER(aa,ab,error_code);
222
223 IF_OPT_COMPARE(aa,ab,crealm) {
224 COMPARE_OPT_STRING(aa,ab,crealm);
225 }
226 #if 0
227 IF_OPT_COMPARE(aa,ab,cname) {
228 COMPARE_OPT_STRING(aa,ab,cname);
229 }
230 #endif
231 COMPARE_STRING(aa,ab,realm);
232
233 COMPARE_INTEGER(aa,ab,sname.name_string.len);
234 for (i = 0; i < aa->sname.name_string.len; i++)
235 COMPARE_STRING(aa,ab,sname.name_string.val[i]);
236
237 IF_OPT_COMPARE(aa,ab,e_text) {
238 COMPARE_OPT_STRING(aa,ab,e_text);
239 }
240 IF_OPT_COMPARE(aa,ab,e_data) {
241 /* COMPARE_OPT_OCTET_STRING(aa,ab,e_data); */
242 }
243
244 return 0;
245 }
246
247 static int
248 test_krb_error (void)
249 {
250 struct test_case tests[] = {
251 { NULL, 127,
252 "\x7e\x7d\x30\x7b\xa0\x03\x02\x01\x05\xa1\x03\x02\x01\x1e\xa4\x11"
253 "\x18\x0f\x32\x30\x30\x33\x31\x31\x32\x34\x30\x30\x31\x31\x31\x39"
254 "\x5a\xa5\x05\x02\x03\x04\xed\xa5\xa6\x03\x02\x01\x1f\xa7\x0d\x1b"
255 "\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45\xa8\x10\x30\x0e"
256 "\xa0\x03\x02\x01\x01\xa1\x07\x30\x05\x1b\x03\x6c\x68\x61\xa9\x0d"
257 "\x1b\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45\xaa\x20\x30"
258 "\x1e\xa0\x03\x02\x01\x01\xa1\x17\x30\x15\x1b\x06\x6b\x72\x62\x74"
259 "\x67\x74\x1b\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45",
260 "KRB-ERROR Test 1"
261 }
262 };
263 int ntests = sizeof(tests) / sizeof(*tests);
264 KRB_ERROR e1;
265 PrincipalName lhaprincipalname = { 1, { 1, lha_principal } };
266 PrincipalName tgtprincipalname = { 1, { 2, nada_tgt_principal } };
267 char *realm = "NADA.KTH.SE";
268
269 e1.pvno = 5;
270 e1.msg_type = 30;
271 e1.ctime = NULL;
272 e1.cusec = NULL;
273 e1.stime = 1069632679;
274 e1.susec = 322981;
275 e1.error_code = 31;
276 e1.crealm = &realm;
277 e1.cname = &lhaprincipalname;
278 e1.realm = "NADA.KTH.SE";
279 e1.sname = tgtprincipalname;
280 e1.e_text = NULL;
281 e1.e_data = NULL;
282
283 tests[0].val = &e1;
284
285 return generic_test (tests, ntests, sizeof(KRB_ERROR),
286 (generic_encode)encode_KRB_ERROR,
287 (generic_length)length_KRB_ERROR,
288 (generic_decode)decode_KRB_ERROR,
289 (generic_free)free_KRB_ERROR,
290 cmp_KRB_ERROR,
291 (generic_copy)copy_KRB_ERROR);
292 }
293
294 static int
295 cmp_Name (void *a, void *b)
296 {
297 Name *aa = a;
298 Name *ab = b;
299
300 COMPARE_INTEGER(aa,ab,element);
301
302 return 0;
303 }
304
305 static int
306 test_Name (void)
307 {
308 struct test_case tests[] = {
309 { NULL, 35,
310 "\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
311 "\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
312 "\x4f\x4c\x4d",
313 "Name CN=Love+L=STOCKHOLM"
314 },
315 { NULL, 35,
316 "\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
317 "\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
318 "\x4f\x4c\x4d",
319 "Name L=STOCKHOLM+CN=Love"
320 }
321 };
322
323 int ntests = sizeof(tests) / sizeof(*tests);
324 Name n1, n2;
325 RelativeDistinguishedName rdn1[1];
326 RelativeDistinguishedName rdn2[1];
327 AttributeTypeAndValue atv1[2];
328 AttributeTypeAndValue atv2[2];
329 unsigned cmp_CN[] = { 2, 5, 4, 3 };
330 unsigned cmp_L[] = { 2, 5, 4, 7 };
331
332 /* n1 */
333 n1.element = choice_Name_rdnSequence;
334 n1.u.rdnSequence.val = rdn1;
335 n1.u.rdnSequence.len = sizeof(rdn1)/sizeof(rdn1[0]);
336 rdn1[0].val = atv1;
337 rdn1[0].len = sizeof(atv1)/sizeof(atv1[0]);
338
339 atv1[0].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
340 atv1[0].type.components = cmp_CN;
341 atv1[0].value.element = choice_DirectoryString_printableString;
342 atv1[0].value.u.printableString.data = "Love";
343 atv1[0].value.u.printableString.length = 4;
344
345 atv1[1].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
346 atv1[1].type.components = cmp_L;
347 atv1[1].value.element = choice_DirectoryString_printableString;
348 atv1[1].value.u.printableString.data = "STOCKHOLM";
349 atv1[1].value.u.printableString.length = 9;
350
351 /* n2 */
352 n2.element = choice_Name_rdnSequence;
353 n2.u.rdnSequence.val = rdn2;
354 n2.u.rdnSequence.len = sizeof(rdn2)/sizeof(rdn2[0]);
355 rdn2[0].val = atv2;
356 rdn2[0].len = sizeof(atv2)/sizeof(atv2[0]);
357
358 atv2[0].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
359 atv2[0].type.components = cmp_L;
360 atv2[0].value.element = choice_DirectoryString_printableString;
361 atv2[0].value.u.printableString.data = "STOCKHOLM";
362 atv2[0].value.u.printableString.length = 9;
363
364 atv2[1].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
365 atv2[1].type.components = cmp_CN;
366 atv2[1].value.element = choice_DirectoryString_printableString;
367 atv2[1].value.u.printableString.data = "Love";
368 atv2[1].value.u.printableString.length = 4;
369
370 /* */
371 tests[0].val = &n1;
372 tests[1].val = &n2;
373
374 return generic_test (tests, ntests, sizeof(Name),
375 (generic_encode)encode_Name,
376 (generic_length)length_Name,
377 (generic_decode)decode_Name,
378 (generic_free)free_Name,
379 cmp_Name,
380 (generic_copy)copy_Name);
381 }
382
383 static int
384 cmp_KeyUsage (void *a, void *b)
385 {
386 KeyUsage *aa = a;
387 KeyUsage *ab = b;
388
389 return KeyUsage2int(*aa) != KeyUsage2int(*ab);
390 }
391
392 static int
393 test_bit_string (void)
394 {
395 struct test_case tests[] = {
396 { NULL, 4,
397 "\x03\x02\x07\x80",
398 "bitstring 1"
399 },
400 { NULL, 4,
401 "\x03\x02\x05\xa0",
402 "bitstring 2"
403 },
404 { NULL, 5,
405 "\x03\x03\x07\x00\x80",
406 "bitstring 3"
407 },
408 { NULL, 3,
409 "\x03\x01\x00",
410 "bitstring 4"
411 }
412 };
413
414 int ntests = sizeof(tests) / sizeof(*tests);
415 KeyUsage ku1, ku2, ku3, ku4;
416
417 memset(&ku1, 0, sizeof(ku1));
418 ku1.digitalSignature = 1;
419 tests[0].val = &ku1;
420
421 memset(&ku2, 0, sizeof(ku2));
422 ku2.digitalSignature = 1;
423 ku2.keyEncipherment = 1;
424 tests[1].val = &ku2;
425
426 memset(&ku3, 0, sizeof(ku3));
427 ku3.decipherOnly = 1;
428 tests[2].val = &ku3;
429
430 memset(&ku4, 0, sizeof(ku4));
431 tests[3].val = &ku4;
432
433
434 return generic_test (tests, ntests, sizeof(KeyUsage),
435 (generic_encode)encode_KeyUsage,
436 (generic_length)length_KeyUsage,
437 (generic_decode)decode_KeyUsage,
438 (generic_free)free_KeyUsage,
439 cmp_KeyUsage,
440 (generic_copy)copy_KeyUsage);
441 }
442
443 static int
444 cmp_TicketFlags (void *a, void *b)
445 {
446 TicketFlags *aa = a;
447 TicketFlags *ab = b;
448
449 return TicketFlags2int(*aa) != TicketFlags2int(*ab);
450 }
451
452 static int
453 test_bit_string_rfc1510 (void)
454 {
455 struct test_case tests[] = {
456 { NULL, 7,
457 "\x03\x05\x00\x80\x00\x00\x00",
458 "TF bitstring 1"
459 },
460 { NULL, 7,
461 "\x03\x05\x00\x40\x20\x00\x00",
462 "TF bitstring 2"
463 },
464 { NULL, 7,
465 "\x03\x05\x00\x00\x20\x00\x00",
466 "TF bitstring 3"
467 },
468 { NULL, 7,
469 "\x03\x05\x00\x00\x00\x00\x00",
470 "TF bitstring 4"
471 }
472 };
473
474 int ntests = sizeof(tests) / sizeof(*tests);
475 TicketFlags tf1, tf2, tf3, tf4;
476
477 memset(&tf1, 0, sizeof(tf1));
478 tf1.reserved = 1;
479 tests[0].val = &tf1;
480
481 memset(&tf2, 0, sizeof(tf2));
482 tf2.forwardable = 1;
483 tf2.pre_authent = 1;
484 tests[1].val = &tf2;
485
486 memset(&tf3, 0, sizeof(tf3));
487 tf3.pre_authent = 1;
488 tests[2].val = &tf3;
489
490 memset(&tf4, 0, sizeof(tf4));
491 tests[3].val = &tf4;
492
493
494 return generic_test (tests, ntests, sizeof(TicketFlags),
495 (generic_encode)encode_TicketFlags,
496 (generic_length)length_TicketFlags,
497 (generic_decode)decode_TicketFlags,
498 (generic_free)free_TicketFlags,
499 cmp_TicketFlags,
500 (generic_copy)copy_TicketFlags);
501 }
502
503 static int
504 cmp_KerberosTime (void *a, void *b)
505 {
506 KerberosTime *aa = a;
507 KerberosTime *ab = b;
508
509 return *aa != *ab;
510 }
511
512 static int
513 test_time (void)
514 {
515 struct test_case tests[] = {
516 { NULL, 17,
517 "\x18\x0f\x31\x39\x37\x30\x30\x31\x30\x31\x30\x31\x31\x38\x33\x31"
518 "\x5a",
519 "time 1" },
520 { NULL, 17,
521 "\x18\x0f\x32\x30\x30\x39\x30\x35\x32\x34\x30\x32\x30\x32\x34\x30"
522 "\x5a",
523 "time 2" }
524 };
525
526 int ntests = sizeof(tests) / sizeof(*tests);
527 KerberosTime times[] = {
528 4711,
529 1243130560
530 };
531
532 tests[0].val = &times[0];
533 tests[1].val = &times[1];
534
535 return generic_test (tests, ntests, sizeof(KerberosTime),
536 (generic_encode)encode_KerberosTime,
537 (generic_length)length_KerberosTime,
538 (generic_decode)decode_KerberosTime,
539 (generic_free)free_KerberosTime,
540 cmp_KerberosTime,
541 (generic_copy)copy_KerberosTime);
542 }
543
544 struct {
545 const char *cert;
546 size_t len;
547 } certs[] = {
548 {
549 "\x30\x82\x02\x6c\x30\x82\x01\xd5\xa0\x03\x02\x01\x02\x02\x09\x00"
550 "\x99\x32\xde\x61\x0e\x40\x19\x8a\x30\x0d\x06\x09\x2a\x86\x48\x86"
551 "\xf7\x0d\x01\x01\x05\x05\x00\x30\x2a\x31\x1b\x30\x19\x06\x03\x55"
552 "\x04\x03\x0c\x12\x68\x78\x35\x30\x39\x20\x54\x65\x73\x74\x20\x52"
553 "\x6f\x6f\x74\x20\x43\x41\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13"
554 "\x02\x53\x45\x30\x1e\x17\x0d\x30\x39\x30\x34\x32\x36\x32\x30\x32"
555 "\x39\x34\x30\x5a\x17\x0d\x31\x39\x30\x34\x32\x34\x32\x30\x32\x39"
556 "\x34\x30\x5a\x30\x2a\x31\x1b\x30\x19\x06\x03\x55\x04\x03\x0c\x12"
557 "\x68\x78\x35\x30\x39\x20\x54\x65\x73\x74\x20\x52\x6f\x6f\x74\x20"
558 "\x43\x41\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x30"
559 "\x81\x9f\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05"
560 "\x00\x03\x81\x8d\x00\x30\x81\x89\x02\x81\x81\x00\xb9\xd3\x1b\x67"
561 "\x1c\xf7\x5e\x26\x81\x3b\x82\xff\x03\xa4\x43\xb5\xb2\x63\x0b\x89"
562 "\x58\x43\xfe\x3d\xe0\x38\x7d\x93\x74\xbb\xad\x21\xa4\x29\xd9\x34"
563 "\x79\xf3\x1c\x8c\x5a\xd6\xb0\xd7\x19\xea\xcc\xaf\xe0\xa8\x40\x02"
564 "\x1d\x91\xf1\xac\x36\xb0\xfb\x08\xbd\xcc\x9a\xe1\xb7\x6e\xee\x0a"
565 "\x69\xbf\x6d\x2b\xee\x20\x82\x61\x06\xf2\x18\xcc\x89\x11\x64\x7e"
566 "\xb2\xff\x47\xd1\x3b\x52\x73\xeb\x5a\xc0\x03\xa6\x4b\xc7\x40\x7e"
567 "\xbc\xe1\x0e\x65\x44\x3f\x40\x8b\x02\x82\x54\x04\xd9\xcc\x2c\x67"
568 "\x01\xb6\x16\x82\xd8\x33\x53\x17\xd7\xde\x8d\x5d\x02\x03\x01\x00"
569 "\x01\xa3\x81\x99\x30\x81\x96\x30\x1d\x06\x03\x55\x1d\x0e\x04\x16"
570 "\x04\x14\x6e\x48\x13\xdc\xbf\x8b\x95\x4c\x13\xf3\x1f\x97\x30\xdd"
571 "\x27\x96\x59\x9b\x0e\x68\x30\x5a\x06\x03\x55\x1d\x23\x04\x53\x30"
572 "\x51\x80\x14\x6e\x48\x13\xdc\xbf\x8b\x95\x4c\x13\xf3\x1f\x97\x30"
573 "\xdd\x27\x96\x59\x9b\x0e\x68\xa1\x2e\xa4\x2c\x30\x2a\x31\x1b\x30"
574 "\x19\x06\x03\x55\x04\x03\x0c\x12\x68\x78\x35\x30\x39\x20\x54\x65"
575 "\x73\x74\x20\x52\x6f\x6f\x74\x20\x43\x41\x31\x0b\x30\x09\x06\x03"
576 "\x55\x04\x06\x13\x02\x53\x45\x82\x09\x00\x99\x32\xde\x61\x0e\x40"
577 "\x19\x8a\x30\x0c\x06\x03\x55\x1d\x13\x04\x05\x30\x03\x01\x01\xff"
578 "\x30\x0b\x06\x03\x55\x1d\x0f\x04\x04\x03\x02\x01\xe6\x30\x0d\x06"
579 "\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x03\x81\x81\x00"
580 "\x52\x9b\xe4\x0e\xee\xc2\x5d\xb7\xf1\xba\x47\xe3\xfe\xaf\x3d\x51"
581 "\x10\xfd\xe8\x0d\x14\x58\x05\x36\xa7\xeb\xd8\x05\xe5\x27\x6f\x51"
582 "\xb8\xec\x90\xd9\x03\xe1\xbc\x9c\x93\x38\x21\x5c\xaf\x4e\x6c\x7b"
583 "\x6c\x65\xa9\x92\xcd\x94\xef\xa8\xae\x90\x12\x14\x78\x2d\xa3\x15"
584 "\xaa\x42\xf1\xd9\x44\x64\x2c\x3c\xc0\xbd\x3a\x48\xd8\x80\x45\x8b"
585 "\xd1\x79\x82\xe0\x0f\xdf\x08\x3c\x60\x21\x6f\x31\x47\x98\xae\x2f"
586 "\xcb\xb1\xa1\xb9\xc1\xa3\x71\x5e\x4a\xc2\x67\xdf\x66\x0a\x51\xb5"
587 "\xad\x60\x05\xdb\x02\xd4\x1a\xd2\xb9\x4e\x01\x08\x2b\xc3\x57\xaf",
588 624 },
589 {
590 "\x30\x82\x02\x54\x30\x82\x01\xbd\xa0\x03\x02\x01\x02\x02\x01\x08"
591 "\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x30"
592 "\x2a\x31\x1b\x30\x19\x06\x03\x55\x04\x03\x0c\x12\x68\x78\x35\x30"
593 "\x39\x20\x54\x65\x73\x74\x20\x52\x6f\x6f\x74\x20\x43\x41\x31\x0b"
594 "\x30\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x30\x1e\x17\x0d\x30"
595 "\x39\x30\x34\x32\x36\x32\x30\x32\x39\x34\x30\x5a\x17\x0d\x31\x39"
596 "\x30\x34\x32\x34\x32\x30\x32\x39\x34\x30\x5a\x30\x1b\x31\x0b\x30"
597 "\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x31\x0c\x30\x0a\x06\x03"
598 "\x55\x04\x03\x0c\x03\x6b\x64\x63\x30\x81\x9f\x30\x0d\x06\x09\x2a"
599 "\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x81\x8d\x00\x30\x81"
600 "\x89\x02\x81\x81\x00\xd2\x41\x7a\xf8\x4b\x55\xb2\xaf\x11\xf9\x43"
601 "\x9b\x43\x81\x09\x3b\x9a\x94\xcf\x00\xf4\x85\x75\x92\xd7\x2a\xa5"
602 "\x11\xf1\xa8\x50\x6e\xc6\x84\x74\x24\x17\xda\x84\xc8\x03\x37\xb2"
603 "\x20\xf3\xba\xb5\x59\x36\x21\x4d\xab\x70\xe2\xc3\x09\x93\x68\x14"
604 "\x12\x79\xc5\xbb\x9e\x1b\x4a\xf0\xc6\x24\x59\x25\xc3\x1c\xa8\x70"
605 "\x66\x5b\x3e\x41\x8e\xe3\x25\x71\x9a\x94\xa0\x5b\x46\x91\x6f\xdd"
606 "\x58\x14\xec\x89\xe5\x8c\x96\xc5\x38\x60\xe4\xab\xf2\x75\xee\x6e"
607 "\x62\xfc\xe1\xbd\x03\x47\xff\xc4\xbe\x0f\xca\x70\x73\xe3\x74\x58"
608 "\x3a\x2f\x04\x2d\x39\x02\x03\x01\x00\x01\xa3\x81\x98\x30\x81\x95"
609 "\x30\x09\x06\x03\x55\x1d\x13\x04\x02\x30\x00\x30\x0b\x06\x03\x55"
610 "\x1d\x0f\x04\x04\x03\x02\x05\xe0\x30\x12\x06\x03\x55\x1d\x25\x04"
611 "\x0b\x30\x09\x06\x07\x2b\x06\x01\x05\x02\x03\x05\x30\x1d\x06\x03"
612 "\x55\x1d\x0e\x04\x16\x04\x14\x3a\xd3\x73\xff\xab\xdb\x7d\x8d\xc6"
613 "\x3a\xa2\x26\x3e\xae\x78\x95\x80\xc9\xe6\x31\x30\x48\x06\x03\x55"
614 "\x1d\x11\x04\x41\x30\x3f\xa0\x3d\x06\x06\x2b\x06\x01\x05\x02\x02"
615 "\xa0\x33\x30\x31\xa0\x0d\x1b\x0b\x54\x45\x53\x54\x2e\x48\x35\x4c"
616 "\x2e\x53\x45\xa1\x20\x30\x1e\xa0\x03\x02\x01\x01\xa1\x17\x30\x15"
617 "\x1b\x06\x6b\x72\x62\x74\x67\x74\x1b\x0b\x54\x45\x53\x54\x2e\x48"
618 "\x35\x4c\x2e\x53\x45\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01"
619 "\x01\x05\x05\x00\x03\x81\x81\x00\x83\xf4\x14\xa7\x6e\x59\xff\x80"
620 "\x64\xe7\xfa\xcf\x13\x80\x86\xe1\xed\x02\x38\xad\x96\x72\x25\xe5"
621 "\x06\x7a\x9a\xbc\x24\x74\xa9\x75\x55\xb2\x49\x80\x69\x45\x95\x4a"
622 "\x4c\x76\xa9\xe3\x4e\x49\xd3\xc2\x69\x5a\x95\x03\xeb\xba\x72\x23"
623 "\x9c\xfd\x3d\x8b\xc6\x07\x82\x3b\xf4\xf3\xef\x6c\x2e\x9e\x0b\xac"
624 "\x9e\x6c\xbb\x37\x4a\xa1\x9e\x73\xd1\xdc\x97\x61\xba\xfc\xd3\x49"
625 "\xa6\xc2\x4c\x55\x2e\x06\x37\x76\xb5\xef\x57\xe7\x57\x58\x8a\x71"
626 "\x63\xf3\xeb\xe7\x55\x68\x0d\xf6\x46\x4c\xfb\xf9\x43\xbb\x0c\x92"
627 "\x4f\x4e\x22\x7b\x63\xe8\x4f\x9c",
628 600
629 }
630 };
631
632 static int
633 test_cert(void)
634 {
635 Certificate c, c2;
636 size_t size;
637 size_t i;
638 int ret;
639
640 for (i = 0; i < sizeof(certs)/sizeof(certs[0]); i++) {
641
642 ret = decode_Certificate((unsigned char *)certs[i].cert,
643 certs[i].len, &c, &size);
644 if (ret)
645 return ret;
646
647 ret = copy_Certificate(&c, &c2);
648 free_Certificate(&c);
649 if (ret)
650 return ret;
651
652 free_Certificate(&c2);
653 }
654
655 return 0;
656 }
657
658 struct {
659 const char *sd;
660 size_t len;
661 } signeddata[] = {
662 {
663 "\x30\x80\x02\x01\x03\x31\x0b\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a"
664 "\x05\x00\x30\x80\x06\x07\x2b\x06\x01\x05\x02\x03\x03\xa0\x80\x24"
665 "\x80\x04\x50\x30\x4e\xa0\x2b\x30\x29\xa0\x03\x02\x01\x12\xa1\x22"
666 "\x04\x20\x78\xf4\x86\x31\xc6\xc2\xc9\xcb\xef\x0c\xd7\x3a\x2a\xcd"
667 "\x8c\x13\x34\x83\xb1\x5c\xa8\xbe\xbf\x2f\xea\xd2\xbb\xd8\x8c\x18"
668 "\x47\x01\xa1\x1f\x30\x1d\xa0\x03\x02\x01\x0c\xa1\x16\x04\x14\xa6"
669 "\x2c\x52\xb2\x80\x98\x30\x40\xbc\x5f\xb0\x77\x2d\x8a\xd7\xa1\xda"
670 "\x3c\xc5\x62\x00\x00\x00\x00\x00\x00\xa0\x82\x02\x09\x30\x82\x02"
671 "\x05\x30\x82\x01\x6e\xa0\x03\x02\x01\x02\x02\x04\x49\x75\x57\xbf"
672 "\x30\x0b\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x30\x3b\x31"
673 "\x1f\x30\x1d\x06\x03\x55\x04\x03\x0c\x16\x63\x6f\x6d\x2e\x61\x70"
674 "\x70\x6c\x65\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73\x2e\x6b\x64\x63"
675 "\x31\x18\x30\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53\x79\x73\x74\x65"
676 "\x6d\x20\x49\x64\x65\x6e\x74\x69\x74\x79\x30\x1e\x17\x0d\x30\x39"
677 "\x31\x32\x30\x34\x30\x30\x32\x30\x32\x34\x5a\x17\x0d\x32\x39\x31"
678 "\x31\x32\x39\x30\x30\x32\x30\x32\x34\x5a\x30\x3b\x31\x1f\x30\x1d"
679 "\x06\x03\x55\x04\x03\x0c\x16\x63\x6f\x6d\x2e\x61\x70\x70\x6c\x65"
680 "\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73\x2e\x6b\x64\x63\x31\x18\x30"
681 "\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53\x79\x73\x74\x65\x6d\x20\x49"
682 "\x64\x65\x6e\x74\x69\x74\x79\x30\x81\x9f\x30\x0d\x06\x09\x2a\x86"
683 "\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x81\x8d\x00\x30\x81\x89"
684 "\x02\x81\x81\x00\xb2\xc5\x4b\x34\xe3\x93\x99\xbb\xaa\xd1\x70\x62"
685 "\x6c\x9c\xcc\xa6\xbc\x47\xc3\x23\xff\x15\xb9\x11\x27\x0a\xf8\x55"
686 "\x4c\xb2\x43\x34\x75\xad\x55\xbb\xb9\x8a\xd0\x25\x64\xa4\x8c\x82"
687 "\x74\x5d\x89\x52\xe2\x76\x75\x08\x67\xb5\x9c\x9c\x69\x86\x0c\x6d"
688 "\x79\xf7\xa0\xbe\x42\x8f\x90\x46\x0c\x18\xf4\x7a\x56\x17\xa4\x65"
689 "\x00\x3a\x5e\x3e\xbf\xbc\xf5\xe2\x2c\x26\x03\x52\xdd\xd4\x85\x3f"
690 "\x03\xd7\x0c\x45\x7f\xff\xdd\x1e\x70\x6c\x9f\xb0\x8c\xd0\x33\xad"
691 "\x92\x54\x17\x9d\x88\x89\x1a\xee\xef\xf7\x96\x3e\x68\xc3\xd1\x60"
692 "\x47\x86\x80\x5d\x02\x03\x01\x00\x01\xa3\x18\x30\x16\x30\x14\x06"
693 "\x03\x55\x1d\x25\x04\x0d\x30\x0b\x06\x09\x2a\x86\x48\x86\xf7\x63"
694 "\x64\x04\x04\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05"
695 "\x05\x00\x03\x81\x81\x00\x9b\xbb\xaa\x63\x66\xd8\x70\x84\x3e\xf6"
696 "\xa1\x3b\xf3\xe6\xd7\x3d\xfc\x4f\xc9\x45\xaa\x31\x43\x8d\xb5\x72"
697 "\xe4\x34\x95\x7b\x6e\x5f\xe5\xc8\x5e\xaf\x12\x08\x6d\xd7\x25\x76"
698 "\x40\xd5\xdc\x83\x7f\x2f\x74\xd1\x63\xc0\x7c\x26\x4d\x53\x10\xe7"
699 "\xfa\xcc\xf2\x60\x41\x63\xdf\x56\xd6\xd9\xc0\xb4\xd0\x73\x99\x54"
700 "\x40\xad\x90\x79\x2d\xd2\x5e\xcb\x13\x22\x2b\xd0\x76\xef\x8a\x48"
701 "\xfd\xb2\x6e\xca\x04\x4e\x91\x3f\xb4\x63\xad\x22\x3a\xf7\x20\x9c"
702 "\x4c\x0e\x47\x78\xe5\x2a\x85\x0e\x90\x7a\xce\x46\xe6\x15\x02\xb0"
703 "\x83\xe7\xac\xfa\x92\xf8\x31\x81\xe8\x30\x81\xe5\x02\x01\x01\x30"
704 "\x43\x30\x3b\x31\x1f\x30\x1d\x06\x03\x55\x04\x03\x0c\x16\x63\x6f"
705 "\x6d\x2e\x61\x70\x70\x6c\x65\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73"
706 "\x2e\x6b\x64\x63\x31\x18\x30\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53"
707 "\x79\x73\x74\x65\x6d\x20\x49\x64\x65\x6e\x74\x69\x74\x79\x02\x04"
708 "\x49\x75\x57\xbf\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x30"
709 "\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x04\x81"
710 "\x80\x50\x2c\x69\xe1\xd2\xc4\xd1\xcc\xdc\xe0\xe9\x8a\x6b\x6a\x97"
711 "\x1b\xb4\xe0\xa8\x20\xbe\x09\x6d\xe1\x55\x5f\x07\x70\x94\x2e\x14"
712 "\xed\x4e\xb1\x69\x75\x40\xbb\x99\x87\xed\x23\x50\x27\x5f\xaa\xc4"
713 "\x84\x60\x06\xfe\x45\xfd\x7e\x1b\x18\xe0\x0b\x77\x35\x2a\xb2\xf2"
714 "\xe0\x88\x31\xad\x82\x31\x4a\xbc\x6d\x71\x62\xe6\x4d\x33\xb4\x09"
715 "\x6e\x3f\x14\x12\xf2\x89\x29\x31\x84\x60\x2b\xa8\x2d\xe6\xca\x2f"
716 "\x03\x3d\xd4\x69\x89\xb3\x98\xfd\xac\x63\x14\xaf\x6a\x52\x2a\xac"
717 "\xe3\x8e\xfa\x21\x41\x8f\xcc\x04\x2d\x52\xee\x49\x54\x0d\x58\x51"
718 "\x77\x00\x00",
719 883
720 }
721 };
722
723 static int
724 test_SignedData(void)
725 {
726 SignedData sd;
727 size_t size, i;
728 int ret;
729
730 for (i = 0; i < sizeof(signeddata) / sizeof(signeddata[0]); i++) {
731
732 ret = decode_SignedData((unsigned char *)signeddata[i].sd,
733 signeddata[i].len, &sd, &size);
734 if (ret)
735 return ret;
736
737 free_SignedData(&sd);
738 }
739
740 return 0;
741 }
742
743
744 static int
745 cmp_TESTLargeTag (void *a, void *b)
746 {
747 TESTLargeTag *aa = a;
748 TESTLargeTag *ab = b;
749
750 COMPARE_INTEGER(aa,ab,foo);
751 COMPARE_INTEGER(aa,ab,bar);
752 return 0;
753 }
754
755 static int
756 test_large_tag (void)
757 {
758 struct test_case tests[] = {
759 { NULL, 15, "\x30\x0d\xbf\x7f\x03\x02\x01\x01\xbf\x81\x00\x03\x02\x01\x02", "large tag 1" }
760 };
761
762 int ntests = sizeof(tests) / sizeof(*tests);
763 TESTLargeTag lt1;
764
765 memset(&lt1, 0, sizeof(lt1));
766 lt1.foo = 1;
767 lt1.bar = 2;
768
769 tests[0].val = &lt1;
770
771 return generic_test (tests, ntests, sizeof(TESTLargeTag),
772 (generic_encode)encode_TESTLargeTag,
773 (generic_length)length_TESTLargeTag,
774 (generic_decode)decode_TESTLargeTag,
775 (generic_free)free_TESTLargeTag,
776 cmp_TESTLargeTag,
777 (generic_copy)copy_TESTLargeTag);
778 }
779
780 struct test_data {
781 int ok;
782 size_t len;
783 size_t expected_len;
784 void *data;
785 };
786
787 static int
788 check_tag_length(void)
789 {
790 struct test_data td[] = {
791 { 1, 3, 3, "\x02\x01\x00"},
792 { 1, 3, 3, "\x02\x01\x7f"},
793 { 1, 4, 4, "\x02\x02\x00\x80"},
794 { 1, 4, 4, "\x02\x02\x01\x00"},
795 { 1, 4, 4, "\x02\x02\x02\x00"},
796 { 0, 3, 0, "\x02\x02\x00"},
797 { 0, 3, 0, "\x02\x7f\x7f"},
798 { 0, 4, 0, "\x02\x03\x00\x80"},
799 { 0, 4, 0, "\x02\x7f\x01\x00"},
800 { 0, 5, 0, "\x02\xff\x7f\x02\x00"}
801 };
802 size_t sz;
803 TESTuint32 values[] = {0, 127, 128, 256, 512,
804 0, 127, 128, 256, 512 };
805 TESTuint32 u;
806 int i, ret, failed = 0;
807 void *buf;
808
809 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
810 struct map_page *page;
811
812 buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
813
814 ret = decode_TESTuint32(buf, td[i].len, &u, &sz);
815 if (ret) {
816 if (td[i].ok) {
817 printf("failed with tag len test %d\n", i);
818 failed = 1;
819 }
820 } else {
821 if (td[i].ok == 0) {
822 printf("failed with success for tag len test %d\n", i);
823 failed = 1;
824 }
825 if (td[i].expected_len != sz) {
826 printf("wrong expected size for tag test %d\n", i);
827 failed = 1;
828 }
829 if (values[i] != u) {
830 printf("wrong value for tag test %d\n", i);
831 failed = 1;
832 }
833 }
834 map_free(page, "test", "decode");
835 }
836 return failed;
837 }
838
839 static int
840 check_tag_length64(void)
841 {
842 struct test_data td[] = {
843 { 1, 3, 3, "\x02\x01\x00"},
844 { 1, 7, 7, "\x02\x05\x01\xff\xff\xff\xff"},
845 { 1, 7, 7, "\x02\x05\x02\x00\x00\x00\x00"},
846 { 1, 9, 9, "\x02\x07\x7f\xff\xff\xff\xff\xff\xff"},
847 { 1, 10, 10, "\x02\x08\x00\x80\x00\x00\x00\x00\x00\x00"},
848 { 1, 10, 10, "\x02\x08\x7f\xff\xff\xff\xff\xff\xff\xff"},
849 { 1, 11, 11, "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"},
850 { 0, 3, 0, "\x02\x02\x00"},
851 { 0, 3, 0, "\x02\x7f\x7f"},
852 { 0, 4, 0, "\x02\x03\x00\x80"},
853 { 0, 4, 0, "\x02\x7f\x01\x00"},
854 { 0, 5, 0, "\x02\xff\x7f\x02\x00"}
855 };
856 size_t sz;
857 TESTuint64 values[] = {0, 8589934591LL, 8589934592LL,
858 36028797018963967LL, 36028797018963968LL,
859 9223372036854775807LL, 18446744073709551615ULL,
860 0, 127, 128, 256, 512 };
861 TESTuint64 u;
862 int i, ret, failed = 0;
863 void *buf;
864
865 if (sizeof(TESTuint64) != sizeof(uint64_t)) {
866 ret += 1;
867 printf("sizeof(TESTuint64) %d != sizeof(uint64_t) %d\n",
868 (int)sizeof(TESTuint64), (int)sizeof(uint64_t));
869 }
870
871 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
872 struct map_page *page;
873
874 buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
875
876 ret = decode_TESTuint64(buf, td[i].len, &u, &sz);
877 if (ret) {
878 if (td[i].ok) {
879 printf("failed with tag len test %d\n", i);
880 printf("ret = %d\n", ret);
881 failed = 1;
882 }
883 } else {
884 if (td[i].ok == 0) {
885 printf("failed with success for tag len test %d\n", i);
886 failed = 1;
887 }
888 if (td[i].expected_len != sz) {
889 printf("wrong expected size for tag test %d\n", i);
890 printf("sz = %lu\n", (unsigned long)sz);
891 failed = 1;
892 }
893 if (values[i] != u) {
894 printf("wrong value for tag test %d\n", i);
895 printf("Expected value: %llu\nActual value: %llu\n",
896 (unsigned long long)values[i], (unsigned long long)u);
897 failed = 1;
898 }
899 }
900 map_free(page, "test", "decode");
901 }
902 return failed;
903 }
904
905 static int
906 check_tag_length64s(void)
907 {
908 struct test_data td[] = {
909 { 1, 3, 3, "\x02\x01\x00"},
910 { 1, 7, 7, "\x02\x05\xfe\x00\x00\x00\x01"},
911 { 1, 7, 7, "\x02\x05\xfe\x00\x00\x00\x00"},
912 { 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x01"},
913 { 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x00"},
914 { 1, 10, 10, "\x02\x08\x80\x00\x00\x00\x00\x00\x00\x01"},
915 { 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x01"},
916 { 0, 3, 0, "\x02\x02\x00"},
917 { 0, 3, 0, "\x02\x7f\x7f"},
918 { 0, 4, 0, "\x02\x03\x00\x80"},
919 { 0, 4, 0, "\x02\x7f\x01\x00"},
920 { 0, 5, 0, "\x02\xff\x7f\x02\x00"}
921 };
922 size_t sz;
923 TESTint64 values[] = {0, -8589934591LL, -8589934592LL,
924 -36028797018963967LL, -36028797018963968LL,
925 -9223372036854775807LL, -36028797018963967LL,
926 0, 127, 128, 256, 512 };
927 TESTint64 u;
928 int i, ret, failed = 0;
929 void *buf;
930
931 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
932 struct map_page *page;
933
934 buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
935
936 ret = decode_TESTint64(buf, td[i].len, &u, &sz);
937 if (ret) {
938 if (td[i].ok) {
939 printf("failed with tag len test %d\n", i);
940 printf("ret = %d\n", ret);
941 failed = 1;
942 }
943 } else {
944 if (td[i].ok == 0) {
945 printf("failed with success for tag len test %d\n", i);
946 failed = 1;
947 }
948 if (td[i].expected_len != sz) {
949 printf("wrong expected size for tag test %d\n", i);
950 printf("sz = %lu\n", (unsigned long)sz);
951 failed = 1;
952 }
953 if (values[i] != u) {
954 printf("wrong value for tag test %d\n", i);
955 printf("Expected value: %lld\nActual value: %lld\n",
956 (long long)values[i], (long long)u);
957 failed = 1;
958 }
959 }
960 map_free(page, "test", "decode");
961 }
962 return failed;
963 }
964
965 static int
966 cmp_TESTChoice (void *a, void *b)
967 {
968 return 0;
969 }
970
971 static int
972 test_choice (void)
973 {
974 struct test_case tests[] = {
975 { NULL, 5, "\xa1\x03\x02\x01\x01", "large choice 1" },
976 { NULL, 5, "\xa2\x03\x02\x01\x02", "large choice 2" }
977 };
978
979 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
980 TESTChoice1 c1;
981 TESTChoice1 c2_1;
982 TESTChoice2 c2_2;
983
984 memset(&c1, 0, sizeof(c1));
985 c1.element = choice_TESTChoice1_i1;
986 c1.u.i1 = 1;
987 tests[0].val = &c1;
988
989 memset(&c2_1, 0, sizeof(c2_1));
990 c2_1.element = choice_TESTChoice1_i2;
991 c2_1.u.i2 = 2;
992 tests[1].val = &c2_1;
993
994 ret += generic_test (tests, ntests, sizeof(TESTChoice1),
995 (generic_encode)encode_TESTChoice1,
996 (generic_length)length_TESTChoice1,
997 (generic_decode)decode_TESTChoice1,
998 (generic_free)free_TESTChoice1,
999 cmp_TESTChoice,
1000 (generic_copy)copy_TESTChoice1);
1001
1002 memset(&c2_2, 0, sizeof(c2_2));
1003 c2_2.element = choice_TESTChoice2_asn1_ellipsis;
1004 c2_2.u.asn1_ellipsis.data = "\xa2\x03\x02\x01\x02";
1005 c2_2.u.asn1_ellipsis.length = 5;
1006 tests[1].val = &c2_2;
1007
1008 ret += generic_test (tests, ntests, sizeof(TESTChoice2),
1009 (generic_encode)encode_TESTChoice2,
1010 (generic_length)length_TESTChoice2,
1011 (generic_decode)decode_TESTChoice2,
1012 (generic_free)free_TESTChoice2,
1013 cmp_TESTChoice,
1014 (generic_copy)copy_TESTChoice2);
1015
1016 return ret;
1017 }
1018
1019 /* Test --decorate=TYPE:FIELD-TYPE:field-name[?] */
1020 static int
1021 test_decorated(void)
1022 {
1023 TESTNotDecorated tnd;
1024 TESTDecorated td;
1025 size_t len, size;
1026 void *ptr;
1027 int ret;
1028
1029 memset(&td, 0, sizeof(td));
1030 memset(&tnd, 0, sizeof(tnd));
1031
1032 td.version = 3;
1033 if ((td.version2 = malloc(sizeof(*td.version2))) == NULL)
1034 errx(1, "out of memory");
1035 *td.version2 = 5;
1036 ASN1_MALLOC_ENCODE(TESTDecorated, ptr, len, &td, &size, ret);
1037 if (ret) {
1038 warnx("could not encode a TESTDecorated struct");
1039 return 1;
1040 }
1041 ret = decode_TESTNotDecorated(ptr, len, &tnd, &size);
1042 if (ret) {
1043 warnx("could not decode a TESTDecorated struct as TESTNotDecorated");
1044 return 1;
1045 }
1046 if (size != len) {
1047 warnx("TESTDecorated encoded size mismatch");
1048 return 1;
1049 }
1050 if (td.version != tnd.version) {
1051 warnx("TESTDecorated did not decode as a TESTNotDecorated correctly");
1052 return 1;
1053 }
1054 free_TESTDecorated(&td);
1055 if (td.version2) {
1056 warnx("free_TESTDecorated() did not work correctly");
1057 return 1;
1058 }
1059 return 0;
1060 }
1061
1062
1063 static int
1064 cmp_TESTImplicit (void *a, void *b)
1065 {
1066 TESTImplicit *aa = a;
1067 TESTImplicit *ab = b;
1068
1069 COMPARE_INTEGER(aa,ab,ti1);
1070 COMPARE_INTEGER(aa,ab,ti2.foo);
1071 COMPARE_INTEGER(aa,ab,ti3);
1072 return 0;
1073 }
1074
1075 static int
1076 cmp_TESTImplicit2 (void *a, void *b)
1077 {
1078 TESTImplicit2 *aa = a;
1079 TESTImplicit2 *ab = b;
1080
1081 COMPARE_INTEGER(aa,ab,ti1);
1082 COMPARE_INTEGER(aa,ab,ti3);
1083 IF_OPT_COMPARE(aa,ab,ti4) {
1084 COMPARE_INTEGER(aa,ab,ti4[0]);
1085 }
1086 return 0;
1087 }
1088
1089 static int
1090 cmp_TESTImplicit3 (void *a, void *b)
1091 {
1092 TESTImplicit3 *aa = a;
1093 TESTImplicit3 *ab = b;
1094
1095 COMPARE_INTEGER(aa,ab,element);
1096 if (aa->element == choice_TESTImplicit3_ti1) {
1097 COMPARE_INTEGER(aa,ab,u.ti1);
1098 } else {
1099 COMPARE_INTEGER(aa,ab,u.ti2.element);
1100 COMPARE_INTEGER(aa,ab,u.ti2.u.i1);
1101 }
1102 return 0;
1103 }
1104
1105 static int
1106 cmp_TESTImplicit4 (void *a, void *b)
1107 {
1108 TESTImplicit4 *aa = a;
1109 TESTImplicit4 *ab = b;
1110
1111 COMPARE_INTEGER(aa,ab,element);
1112 if (aa->element == choice_TESTImplicit4_ti1) {
1113 COMPARE_INTEGER(aa,ab,u.ti1);
1114 } else {
1115 COMPARE_INTEGER(aa,ab,u.ti2.element);
1116 COMPARE_INTEGER(aa,ab,u.ti2.u.i1);
1117 }
1118 return 0;
1119 }
1120
1121 static int
1122 test_implicit (void)
1123 {
1124 int ret = 0;
1125 /*
1126 * UNIV CONS Sequence = 14 bytes {
1127 * CONTEXT PRIM tag 0 = 1 bytes [0] IMPLICIT content
1128 * CONTEXT CONS tag 1 = 6 bytes [1]
1129 * CONTEXT CONS tag 127 = 3 bytes [127]
1130 * UNIV PRIM Integer = integer 2
1131 * CONTEXT PRIM tag 2 = 1 bytes [2] IMPLICIT content
1132 * }
1133 */
1134 struct test_case tests[] = {
1135 { NULL, 16,
1136 "\x30\x0e\x80\x01\x00\xa1\x06\xbf\x7f\x03\x02\x01\x02\x82\x01\x03",
1137 "implicit 1" }
1138 };
1139 /*
1140 * UNIV CONS Sequence = 10 bytes {
1141 * CONTEXT PRIM tag 0 = 1 bytes [0] IMPLICIT content
1142 * CONTEXT PRIM tag 2 = 1 bytes [2] IMPLICIT content
1143 * CONTEXT PRIM tag 51 = 1 bytes [51] IMPLICIT content
1144 * }
1145 */
1146 struct test_case tests2[] = {
1147 { NULL, 12,
1148 "\x30\x0a\x80\x01\x01\x82\x01\x03\x9f\x33\x01\x04",
1149 "implicit 2" }
1150 };
1151 /*
1152 * CONTEXT CONS tag 5 = 5 bytes [5]
1153 * CONTEXT CONS tag 1 = 3 bytes [1]
1154 * UNIV PRIM Integer = integer 5
1155 */
1156 struct test_case tests3[] = {
1157 { NULL, 7,
1158 "\xa5\x05\xa1\x03\x02\x01\x05",
1159 "implicit 3" }
1160 };
1161 /*
1162 * Notice: same as tests3[].bytes.
1163 *
1164 * CONTEXT CONS tag 5 = 5 bytes [5]
1165 * CONTEXT CONS tag 1 = 3 bytes [1]
1166 * UNIV PRIM Integer = integer 5
1167 */
1168 struct test_case tests4[] = {
1169 { NULL, 7,
1170 "\xa5\x05\xa1\x03\x02\x01\x05",
1171 "implicit 4" }
1172 };
1173
1174 TESTImplicit c0;
1175 TESTImplicit2 c1;
1176 TESTImplicit3 c2;
1177 TESTImplicit4 c3;
1178 int ti4 = 4;
1179
1180 memset(&c0, 0, sizeof(c0));
1181 c0.ti1 = 0;
1182 c0.ti2.foo = 2;
1183 c0.ti3 = 3;
1184 tests[0].val = &c0;
1185
1186 memset(&c1, 0, sizeof(c1));
1187 c1.ti1 = 1;
1188 c1.ti3 = 3;
1189 c1.ti4 = &ti4;
1190 tests2[0].val = &c1;
1191
1192 memset(&c2, 0, sizeof(c2));
1193 c2.element = choice_TESTImplicit3_ti2;
1194 c2.u.ti2.element = choice_TESTImplicit3_ti2_i1;
1195 c2.u.ti2.u.i1 = 5;
1196 tests3[0].val = &c2;
1197
1198 memset(&c3, 0, sizeof(c3));
1199 c3.element = choice_TESTImplicit4_ti2;
1200 c3.u.ti2.element = choice_TESTChoice2_i1;
1201 c3.u.ti2.u.i1 = 5;
1202 tests4[0].val = &c3;
1203
1204 ret += generic_test(tests,
1205 sizeof(tests) / sizeof(*tests),
1206 sizeof(TESTImplicit),
1207 (generic_encode)encode_TESTImplicit,
1208 (generic_length)length_TESTImplicit,
1209 (generic_decode)decode_TESTImplicit,
1210 (generic_free)free_TESTImplicit,
1211 cmp_TESTImplicit,
1212 (generic_copy)copy_TESTImplicit);
1213
1214 ret += generic_test(tests2,
1215 sizeof(tests2) / sizeof(*tests2),
1216 sizeof(TESTImplicit2),
1217 (generic_encode)encode_TESTImplicit2,
1218 (generic_length)length_TESTImplicit2,
1219 (generic_decode)decode_TESTImplicit2,
1220 (generic_free)free_TESTImplicit2,
1221 cmp_TESTImplicit2,
1222 NULL);
1223
1224 ret += generic_test(tests3,
1225 sizeof(tests3) / sizeof(*tests3),
1226 sizeof(TESTImplicit3),
1227 (generic_encode)encode_TESTImplicit3,
1228 (generic_length)length_TESTImplicit3,
1229 (generic_decode)decode_TESTImplicit3,
1230 (generic_free)free_TESTImplicit3,
1231 cmp_TESTImplicit3,
1232 NULL);
1233
1234 ret += generic_test(tests4,
1235 sizeof(tests4) / sizeof(*tests4),
1236 sizeof(TESTImplicit4),
1237 (generic_encode)encode_TESTImplicit4,
1238 (generic_length)length_TESTImplicit4,
1239 (generic_decode)decode_TESTImplicit4,
1240 (generic_free)free_TESTImplicit4,
1241 cmp_TESTImplicit4,
1242 NULL);
1243
1244 return ret;
1245 }
1246
1247 static int
1248 cmp_TESTAlloc (void *a, void *b)
1249 {
1250 TESTAlloc *aa = a;
1251 TESTAlloc *ab = b;
1252
1253 IF_OPT_COMPARE(aa,ab,tagless) {
1254 COMPARE_INTEGER(aa,ab,tagless->ai);
1255 }
1256
1257 COMPARE_INTEGER(aa,ab,three);
1258
1259 IF_OPT_COMPARE(aa,ab,tagless2) {
1260 COMPARE_OPT_OCTET_STRING(aa, ab, tagless2);
1261 }
1262
1263 return 0;
1264 }
1265
1266 /*
1267 UNIV CONS Sequence 12
1268 UNIV CONS Sequence 5
1269 CONTEXT CONS 0 3
1270 UNIV PRIM Integer 1 01
1271 CONTEXT CONS 1 3
1272 UNIV PRIM Integer 1 03
1273
1274 UNIV CONS Sequence 5
1275 CONTEXT CONS 1 3
1276 UNIV PRIM Integer 1 03
1277
1278 UNIV CONS Sequence 8
1279 CONTEXT CONS 1 3
1280 UNIV PRIM Integer 1 04
1281 UNIV PRIM Integer 1 05
1282
1283 */
1284
1285 static int
1286 test_taglessalloc (void)
1287 {
1288 struct test_case tests[] = {
1289 { NULL, 14,
1290 "\x30\x0c\x30\x05\xa0\x03\x02\x01\x01\xa1\x03\x02\x01\x03",
1291 "alloc 1" },
1292 { NULL, 7,
1293 "\x30\x05\xa1\x03\x02\x01\x03",
1294 "alloc 2" },
1295 { NULL, 10,
1296 "\x30\x08\xa1\x03\x02\x01\x04\x02\x01\x05",
1297 "alloc 3" }
1298 };
1299
1300 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
1301 TESTAlloc c1, c2, c3;
1302 heim_any any3;
1303
1304 memset(&c1, 0, sizeof(c1));
1305 c1.tagless = ecalloc(1, sizeof(*c1.tagless));
1306 c1.tagless->ai = 1;
1307 c1.three = 3;
1308 tests[0].val = &c1;
1309
1310 memset(&c2, 0, sizeof(c2));
1311 c2.tagless = NULL;
1312 c2.three = 3;
1313 tests[1].val = &c2;
1314
1315 memset(&c3, 0, sizeof(c3));
1316 c3.tagless = NULL;
1317 c3.three = 4;
1318 c3.tagless2 = &any3;
1319 any3.data = "\x02\x01\x05";
1320 any3.length = 3;
1321 tests[2].val = &c3;
1322
1323 ret += generic_test (tests, ntests, sizeof(TESTAlloc),
1324 (generic_encode)encode_TESTAlloc,
1325 (generic_length)length_TESTAlloc,
1326 (generic_decode)decode_TESTAlloc,
1327 (generic_free)free_TESTAlloc,
1328 cmp_TESTAlloc,
1329 (generic_copy)copy_TESTAlloc);
1330
1331 free(c1.tagless);
1332
1333 return ret;
1334 }
1335
1336 static int
1337 cmp_TESTOptional (void *a, void *b)
1338 {
1339 TESTOptional *aa = a;
1340 TESTOptional *ab = b;
1341
1342 IF_OPT_COMPARE(aa,ab,zero) {
1343 COMPARE_OPT_INTEGER(aa,ab,zero);
1344 }
1345 IF_OPT_COMPARE(aa,ab,one) {
1346 COMPARE_OPT_INTEGER(aa,ab,one);
1347 }
1348 return 0;
1349 }
1350
1351 /*
1352 UNIV CONS Sequence 5
1353 CONTEXT CONS 0 3
1354 UNIV PRIM Integer 1 00
1355
1356 UNIV CONS Sequence 5
1357 CONTEXT CONS 1 3
1358 UNIV PRIM Integer 1 03
1359
1360 UNIV CONS Sequence 10
1361 CONTEXT CONS 0 3
1362 UNIV PRIM Integer 1 00
1363 CONTEXT CONS 1 3
1364 UNIV PRIM Integer 1 01
1365
1366 */
1367
1368 static int
1369 test_optional (void)
1370 {
1371 struct test_case tests[] = {
1372 { NULL, 2,
1373 "\x30\x00",
1374 "optional 0" },
1375 { NULL, 7,
1376 "\x30\x05\xa0\x03\x02\x01\x00",
1377 "optional 1" },
1378 { NULL, 7,
1379 "\x30\x05\xa1\x03\x02\x01\x01",
1380 "optional 2" },
1381 { NULL, 12,
1382 "\x30\x0a\xa0\x03\x02\x01\x00\xa1\x03\x02\x01\x01",
1383 "optional 3" }
1384 };
1385
1386 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
1387 TESTOptional c0, c1, c2, c3;
1388 int zero = 0;
1389 int one = 1;
1390
1391 c0.zero = NULL;
1392 c0.one = NULL;
1393 tests[0].val = &c0;
1394
1395 c1.zero = &zero;
1396 c1.one = NULL;
1397 tests[1].val = &c1;
1398
1399 c2.zero = NULL;
1400 c2.one = &one;
1401 tests[2].val = &c2;
1402
1403 c3.zero = &zero;
1404 c3.one = &one;
1405 tests[3].val = &c3;
1406
1407 ret += generic_test (tests, ntests, sizeof(TESTOptional),
1408 (generic_encode)encode_TESTOptional,
1409 (generic_length)length_TESTOptional,
1410 (generic_decode)decode_TESTOptional,
1411 (generic_free)free_TESTOptional,
1412 cmp_TESTOptional,
1413 (generic_copy)copy_TESTOptional);
1414
1415 return ret;
1416 }
1417
1418 static int
1419 check_fail_largetag(void)
1420 {
1421 struct test_case tests[] = {
1422 {NULL, 14, "\x30\x0c\xbf\x87\xff\xff\xff\xff\xff\x7f\x03\x02\x01\x01",
1423 "tag overflow"},
1424 {NULL, 0, "", "empty buffer"},
1425 {NULL, 7, "\x30\x05\xa1\x03\x02\x02\x01",
1426 "one too short" },
1427 {NULL, 7, "\x30\x04\xa1\x03\x02\x02\x01",
1428 "two too short" },
1429 {NULL, 7, "\x30\x03\xa1\x03\x02\x02\x01",
1430 "three too short" },
1431 {NULL, 7, "\x30\x02\xa1\x03\x02\x02\x01",
1432 "four too short" },
1433 {NULL, 7, "\x30\x01\xa1\x03\x02\x02\x01",
1434 "five too short" },
1435 {NULL, 7, "\x30\x00\xa1\x03\x02\x02\x01",
1436 "six too short" },
1437 {NULL, 7, "\x30\x05\xa1\x04\x02\x02\x01",
1438 "inner one too long" },
1439 {NULL, 7, "\x30\x00\xa1\x02\x02\x02\x01",
1440 "inner one too short" },
1441 {NULL, 8, "\x30\x05\xbf\x7f\x03\x02\x02\x01",
1442 "inner one too short"},
1443 {NULL, 8, "\x30\x06\xbf\x64\x03\x02\x01\x01",
1444 "wrong tag"},
1445 {NULL, 10, "\x30\x08\xbf\x9a\x9b\x38\x03\x02\x01\x01",
1446 "still wrong tag"}
1447 };
1448 int ntests = sizeof(tests) / sizeof(*tests);
1449
1450 return generic_decode_fail(tests, ntests, sizeof(TESTLargeTag),
1451 (generic_decode)decode_TESTLargeTag);
1452 }
1453
1454
1455 static int
1456 check_fail_sequence(void)
1457 {
1458 struct test_case tests[] = {
1459 {NULL, 0, "", "empty buffer"},
1460 {NULL, 24,
1461 "\x30\x16\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
1462 "\x02\x01\x01\xa2\x03\x02\x01\x01",
1463 "missing one byte from the end, internal length ok"},
1464 {NULL, 25,
1465 "\x30\x18\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
1466 "\x02\x01\x01\xa2\x03\x02\x01\x01",
1467 "inner length one byte too long"},
1468 {NULL, 24,
1469 "\x30\x17\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01"
1470 "\x01\x02\x01\x01\xa2\x03\x02\x01\x01",
1471 "correct buffer but missing one too short"}
1472 };
1473 int ntests = sizeof(tests) / sizeof(*tests);
1474
1475 return generic_decode_fail(tests, ntests, sizeof(TESTSeq),
1476 (generic_decode)decode_TESTSeq);
1477 }
1478
1479 static int
1480 check_fail_choice(void)
1481 {
1482 struct test_case tests[] = {
1483 {NULL, 6,
1484 "\xa1\x02\x02\x01\x01",
1485 "choice one too short"},
1486 {NULL, 6,
1487 "\xa1\x03\x02\x02\x01",
1488 "choice one too short inner"}
1489 };
1490 int ntests = sizeof(tests) / sizeof(*tests);
1491
1492 return generic_decode_fail(tests, ntests, sizeof(TESTChoice1),
1493 (generic_decode)decode_TESTChoice1);
1494 }
1495
1496 static int
1497 check_fail_Ticket(void)
1498 {
1499 char buf[100];
1500 size_t i;
1501 int ret;
1502 struct test_case test;
1503 Ticket ticket;
1504
1505 for (i = 0; i < sizeof(buf); i++) {
1506 memset(buf, 0, sizeof(buf));
1507 memset(&ticket, 0, sizeof(ticket));
1508 test.val = &ticket;
1509 test.byte_len = i;
1510 test.bytes = buf;
1511 test.name = "zero life";
1512 ret = generic_decode_fail(&test, 1, sizeof(Ticket),
1513 (generic_decode)decode_Ticket);
1514 if (ret)
1515 return ret;
1516 }
1517 return 0;
1518 }
1519
1520 static int
1521 check_seq(void)
1522 {
1523 TESTSeqOf seq;
1524 TESTInteger i;
1525 int ret;
1526
1527 seq.val = NULL;
1528 seq.len = 0;
1529
1530 ret = add_TESTSeqOf(&seq, &i);
1531 if (ret) { printf("failed adding\n"); goto out; }
1532 ret = add_TESTSeqOf(&seq, &i);
1533 if (ret) { printf("failed adding\n"); goto out; }
1534 ret = add_TESTSeqOf(&seq, &i);
1535 if (ret) { printf("failed adding\n"); goto out; }
1536 ret = add_TESTSeqOf(&seq, &i);
1537 if (ret) { printf("failed adding\n"); goto out; }
1538
1539 ret = remove_TESTSeqOf(&seq, seq.len - 1);
1540 if (ret) { printf("failed removing\n"); goto out; }
1541 ret = remove_TESTSeqOf(&seq, 2);
1542 if (ret) { printf("failed removing\n"); goto out; }
1543 ret = remove_TESTSeqOf(&seq, 0);
1544 if (ret) { printf("failed removing\n"); goto out; }
1545 ret = remove_TESTSeqOf(&seq, 0);
1546 if (ret) { printf("failed removing\n"); goto out; }
1547 ret = remove_TESTSeqOf(&seq, 0);
1548 if (ret == 0) {
1549 printf("can remove from empty list");
1550 return 1;
1551 }
1552
1553 if (seq.len != 0) {
1554 printf("seq not empty!");
1555 return 1;
1556 }
1557 free_TESTSeqOf(&seq);
1558 ret = 0;
1559
1560 out:
1561
1562 return ret;
1563 }
1564
1565 #define test_seq_of(type, ok, ptr) \
1566 { \
1567 heim_octet_string os; \
1568 size_t size; \
1569 type decode; \
1570 ASN1_MALLOC_ENCODE(type, os.data, os.length, ptr, &size, ret); \
1571 if (ret) \
1572 return ret; \
1573 if (os.length != size) \
1574 abort(); \
1575 ret = decode_##type(os.data, os.length, &decode, &size); \
1576 free(os.data); \
1577 if (ret) { \
1578 if (ok) \
1579 return 1; \
1580 } else { \
1581 free_##type(&decode); \
1582 if (!ok) \
1583 return 1; \
1584 if (size != 0) \
1585 return 1; \
1586 } \
1587 return 0; \
1588 }
1589
1590 static int
1591 check_seq_of_size(void)
1592 {
1593 #if 0 /* template */
1594 TESTInteger integers[4] = { 1, 2, 3, 4 };
1595 int ret;
1596
1597 {
1598 TESTSeqSizeOf1 ssof1f1 = { 1, integers };
1599 TESTSeqSizeOf1 ssof1ok1 = { 2, integers };
1600 TESTSeqSizeOf1 ssof1f2 = { 3, integers };
1601
1602 test_seq_of(TESTSeqSizeOf1, 0, &ssof1f1);
1603 test_seq_of(TESTSeqSizeOf1, 1, &ssof1ok1);
1604 test_seq_of(TESTSeqSizeOf1, 0, &ssof1f2);
1605 }
1606 {
1607 TESTSeqSizeOf2 ssof2f1 = { 0, NULL };
1608 TESTSeqSizeOf2 ssof2ok1 = { 1, integers };
1609 TESTSeqSizeOf2 ssof2ok2 = { 2, integers };
1610 TESTSeqSizeOf2 ssof2f2 = { 3, integers };
1611
1612 test_seq_of(TESTSeqSizeOf2, 0, &ssof2f1);
1613 test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok1);
1614 test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok2);
1615 test_seq_of(TESTSeqSizeOf2, 0, &ssof2f2);
1616 }
1617 {
1618 TESTSeqSizeOf3 ssof3f1 = { 0, NULL };
1619 TESTSeqSizeOf3 ssof3ok1 = { 1, integers };
1620 TESTSeqSizeOf3 ssof3ok2 = { 2, integers };
1621
1622 test_seq_of(TESTSeqSizeOf3, 0, &ssof3f1);
1623 test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok1);
1624 test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok2);
1625 }
1626 {
1627 TESTSeqSizeOf4 ssof4ok1 = { 0, NULL };
1628 TESTSeqSizeOf4 ssof4ok2 = { 1, integers };
1629 TESTSeqSizeOf4 ssof4ok3 = { 2, integers };
1630 TESTSeqSizeOf4 ssof4f1 = { 3, integers };
1631
1632 test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok1);
1633 test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok2);
1634 test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok3);
1635 test_seq_of(TESTSeqSizeOf4, 0, &ssof4f1);
1636 }
1637 #endif
1638 return 0;
1639 }
1640
1641 static int
1642 check_TESTMechTypeList(void)
1643 {
1644 TESTMechTypeList tl;
1645 unsigned oid1[] = { 1, 2, 840, 48018, 1, 2, 2};
1646 unsigned oid2[] = { 1, 2, 840, 113554, 1, 2, 2};
1647 unsigned oid3[] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 30};
1648 unsigned oid4[] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10};
1649 TESTMechType array[] = {{ 7, oid1 },
1650 { 7, oid2 },
1651 { 10, oid3 },
1652 { 10, oid4 }};
1653 size_t size, len;
1654 void *ptr;
1655 int ret;
1656
1657 tl.len = 4;
1658 tl.val = array;
1659
1660 ASN1_MALLOC_ENCODE(TESTMechTypeList, ptr, len, &tl, &size, ret);
1661 if (ret)
1662 errx(1, "TESTMechTypeList: %d", ret);
1663 if (len != size)
1664 abort();
1665 free(ptr);
1666 return 0;
1667 }
1668
1669 static int
1670 cmp_TESTSeqOf4(void *a, void *b)
1671 {
1672 TESTSeqOf4 *aa = a;
1673 TESTSeqOf4 *ab = b;
1674 int i;
1675
1676 IF_OPT_COMPARE(aa, ab, b1) {
1677 COMPARE_INTEGER(aa->b1, ab->b1, len);
1678 for (i = 0; i < aa->b1->len; ++i) {
1679 COMPARE_INTEGER(aa->b1->val+i, ab->b1->val+i, u1);
1680 COMPARE_INTEGER(aa->b1->val+i, ab->b1->val+i, u2);
1681 COMPARE_OCTET_STRING(aa->b1->val+i, ab->b1->val+i, s1);
1682 COMPARE_OCTET_STRING(aa->b1->val+i, ab->b1->val+i, s2);
1683 }
1684 }
1685 IF_OPT_COMPARE(aa, ab, b2) {
1686 COMPARE_INTEGER(aa->b2, ab->b2, len);
1687 for (i = 0; i < aa->b2->len; ++i) {
1688 COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u1);
1689 COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u2);
1690 COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u3);
1691 COMPARE_OCTET_STRING(aa->b2->val+i, ab->b2->val+i, s1);
1692 COMPARE_OCTET_STRING(aa->b2->val+i, ab->b2->val+i, s2);
1693 COMPARE_OCTET_STRING(aa->b2->val+i, ab->b2->val+i, s3);
1694 }
1695 }
1696 IF_OPT_COMPARE(aa, ab, b3) {
1697 COMPARE_INTEGER(aa->b3, ab->b3, len);
1698 for (i = 0; i < aa->b3->len; ++i) {
1699 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u1);
1700 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u2);
1701 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u3);
1702 COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u4);
1703 COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s1);
1704 COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s2);
1705 COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s3);
1706 COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s4);
1707 }
1708 }
1709 return 0;
1710 }
1711
1712 static int
1713 test_seq4 (void)
1714 {
1715 int ret = 0;
1716 struct test_case tests[] = {
1717 { NULL, 2,
1718 "\x30\x00",
1719 "seq4 0" },
1720 { NULL, 4,
1721 "\x30\x02" "\xa1\x00",
1722 "seq4 1" },
1723 { NULL, 8,
1724 "\x30\x06" "\xa0\x02\x30\x00" "\xa1\x00",
1725 "seq4 2" },
1726 { NULL, 2 + (2 + 0x18) + (2 + 0x27) + (2 + 0x31),
1727 "\x30\x76" /* 2 SEQ */
1728 "\xa0\x18\x30\x16" /* 4 [0] SEQ */
1729 "\x30\x14" /* 2 SEQ */
1730 "\x04\x00" /* 2 OCTET-STRING */
1731 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
1732 "\x02\x01\x01" /* 3 INT */
1733 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
1734 /* 11 INT */
1735 "\xa1\x27" /* 2 [1] IMPL SEQ */
1736 "\x30\x25" /* 2 SEQ */
1737 "\x02\x01\x01" /* 3 INT */
1738 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
1739 /* 11 INT */
1740 "\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
1741 /* 11 INT */
1742 "\x04\x00" /* 2 OCTET-STRING */
1743 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
1744 "\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
1745 "\xa2\x31" /* 2 [2] IMPL SEQ */
1746 "\x30\x2f" /* 2 SEQ */
1747 "\x04\x00" /* 2 OCTET-STRING */
1748 "\x02\x01\x01" /* 3 INT */
1749 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
1750 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
1751 /* 11 INT */
1752 "\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
1753 "\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
1754 /* 11 INT */
1755 "\x04\x01\x00" /* 3 OCTET-STRING */
1756 "\x02\x05\x01\x00\x00\x00\x00", /* 7 INT */
1757 "seq4 3" },
1758 };
1759
1760 int ntests = sizeof(tests) / sizeof(*tests);
1761 TESTSeqOf4 c[4];
1762 struct TESTSeqOf4_b1 b1[4];
1763 struct TESTSeqOf4_b2 b2[4];
1764 struct TESTSeqOf4_b3 b3[4];
1765 struct TESTSeqOf4_b1_val b1val[4];
1766 struct TESTSeqOf4_b2_val b2val[4];
1767 struct TESTSeqOf4_b3_val b3val[4];
1768
1769 c[0].b1 = NULL;
1770 c[0].b2 = NULL;
1771 c[0].b3 = NULL;
1772 tests[0].val = &c[0];
1773
1774 b2[1].len = 0;
1775 b2[1].val = NULL;
1776 c[1].b1 = NULL;
1777 c[1].b2 = &b2[1];
1778 c[1].b3 = NULL;
1779 tests[1].val = &c[1];
1780
1781 b1[2].len = 0;
1782 b1[2].val = NULL;
1783 b2[2].len = 0;
1784 b2[2].val = NULL;
1785 c[2].b1 = &b1[2];
1786 c[2].b2 = &b2[2];
1787 c[2].b3 = NULL;
1788 tests[2].val = &c[2];
1789
1790 b1val[3].s1.data = "";
1791 b1val[3].s1.length = 0;
1792 b1val[3].u1 = 1LL;
1793 b1val[3].s2.data = "\x01\x02";
1794 b1val[3].s2.length = 2;
1795 b1val[3].u2 = -1LL;
1796
1797 b2val[3].s1.data = "";
1798 b2val[3].s1.length = 0;
1799 b2val[3].u1 = 1LL;
1800 b2val[3].s2.data = "\x01\x02";
1801 b2val[3].s2.length = 2;
1802 b2val[3].u2 = -1LL;
1803 b2val[3].s3.data = "\x00\x01\x02\x03";
1804 b2val[3].s3.length = 4;
1805 b2val[3].u3 = 1LL<<63;
1806
1807 b3val[3].s1.data = "";
1808 b3val[3].s1.length = 0;
1809 b3val[3].u1 = 1LL;
1810 b3val[3].s2.data = "\x01\x02";
1811 b3val[3].s2.length = 2;
1812 b3val[3].u2 = -1LL;
1813 b3val[3].s3.data = "\x00\x01\x02\x03";
1814 b3val[3].s3.length = 4;
1815 b3val[3].u3 = 1LL<<63;
1816 b3val[3].s4.data = "\x00";
1817 b3val[3].s4.length = 1;
1818 b3val[3].u4 = 1LL<<32;
1819
1820 b1[3].len = 1;
1821 b1[3].val = &b1val[3];
1822 b2[3].len = 1;
1823 b2[3].val = &b2val[3];
1824 b3[3].len = 1;
1825 b3[3].val = &b3val[3];
1826 c[3].b1 = &b1[3];
1827 c[3].b2 = &b2[3];
1828 c[3].b3 = &b3[3];
1829 tests[3].val = &c[3];
1830
1831 ret += generic_test (tests, ntests, sizeof(TESTSeqOf4),
1832 (generic_encode)encode_TESTSeqOf4,
1833 (generic_length)length_TESTSeqOf4,
1834 (generic_decode)decode_TESTSeqOf4,
1835 (generic_free)free_TESTSeqOf4,
1836 cmp_TESTSeqOf4,
1837 (generic_copy)copy_TESTSeqOf4);
1838 return ret;
1839 }
1840
1841 static int
1842 cmp_test_seqof5 (void *a, void *b)
1843 {
1844 TESTSeqOf5 *aval = a;
1845 TESTSeqOf5 *bval = b;
1846
1847 IF_OPT_COMPARE(aval, bval, outer) {
1848 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u0);
1849 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s0);
1850 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u1);
1851 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s1);
1852 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u2);
1853 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s2);
1854 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u3);
1855 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s3);
1856 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u4);
1857 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s4);
1858 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u5);
1859 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s5);
1860 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u6);
1861 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s6);
1862 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u7);
1863 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s7);
1864 }
1865 return 0;
1866 }
1867
1868 static int
1869 test_seqof5(void)
1870 {
1871 struct test_case tests[] = {
1872 { NULL, 2, "\x30\x00", "seq5 0" },
1873 { NULL, 126,
1874 "\x30\x7c" /* SEQ */
1875 "\x30\x7a" /* SEQ */
1876 "\x30\x78" /* SEQ */
1877 "\x02\x01\x01" /* INT 1 */
1878 "\x04\x06\x01\x01\x01\x01\x01\x01" /* "\0x1"x6 */
1879 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfe" /* INT ~1 */
1880 "\x04\x06\x02\x02\x02\x02\x02\x02" /* "\x02"x6 */
1881 "\x02\x01\x02" /* INT 2 */
1882 "\x04\x06\x03\x03\x03\x03\x03\x03" /* "\x03"x6 */
1883 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfd" /* INT ~2 */
1884 "\x04\x06\x04\x04\x04\x04\x04\x04" /* ... */
1885 "\x02\x01\x03"
1886 "\x04\x06\x05\x05\x05\x05\x05\x05"
1887 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfc"
1888 "\x04\x06\x06\x06\x06\x06\x06\x06"
1889 "\x02\x01\x04"
1890 "\x04\x06\x07\x07\x07\x07\x07\x07"
1891 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfb"
1892 "\x04\x06\x08\x08\x08\x08\x08\x08",
1893 "seq5 1" },
1894 };
1895
1896 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
1897 TESTSeqOf5 c[2];
1898 struct TESTSeqOf5_outer outer;
1899 struct TESTSeqOf5_outer_inner inner;
1900 TESTuint64 u[8];
1901 heim_octet_string s[8];
1902 int i;
1903
1904 c[0].outer = NULL;
1905 tests[0].val = &c[0];
1906
1907 for (i = 0; i < 8; ++i) {
1908 u[i] = (i&1) == 0 ? i/2+1 : ~(i/2+1);
1909 s[i].data = memset(malloc(s[i].length = 6), i+1, 6);
1910 }
1911
1912 inner.u0 = u[0]; inner.u1 = u[1]; inner.u2 = u[2]; inner.u3 = u[3];
1913 inner.u4 = u[4]; inner.u5 = u[5]; inner.u6 = u[6]; inner.u7 = u[7];
1914 inner.s0 = s[0]; inner.s1 = s[1]; inner.s2 = s[2]; inner.s3 = s[3];
1915 inner.s4 = s[4]; inner.s5 = s[5]; inner.s6 = s[6]; inner.s7 = s[7];
1916
1917 outer.inner = inner;
1918 c[1].outer = &outer;
1919 tests[1].val = &c[1];
1920
1921 ret += generic_test (tests, ntests, sizeof(TESTSeqOf5),
1922 (generic_encode)encode_TESTSeqOf5,
1923 (generic_length)length_TESTSeqOf5,
1924 (generic_decode)decode_TESTSeqOf5,
1925 (generic_free)free_TESTSeqOf5,
1926 cmp_test_seqof5,
1927 NULL);
1928
1929 for (i = 0; i < 8; ++i)
1930 free(s[i].data);
1931
1932 return ret;
1933 }
1934
1935 static int
1936 cmp_default(void *a, void *b)
1937 {
1938 TESTDefault *aa = a;
1939 TESTDefault *ab = b;
1940
1941 COMPARE_STRING(aa,ab,name);
1942 COMPARE_INTEGER(aa,ab,version);
1943 COMPARE_INTEGER(aa,ab,maxint);
1944 COMPARE_INTEGER(aa,ab,works);
1945 return 0;
1946 }
1947
1948 static int
1949 test_default(void)
1950 {
1951 struct test_case tests[] = {
1952 { NULL, 2, "\x30\x00", NULL },
1953 { NULL, 25,
1954 "\x30\x17\x0c\x07\x68\x65\x69\x6d\x64\x61"
1955 "\x6c\xa0\x03\x02\x01\x07\x02\x04\x7f\xff"
1956 "\xff\xff\x01\x01\x00",
1957 NULL
1958 },
1959 { NULL, 10,
1960 "\x30\x08\xa0\x03\x02\x01\x07\x01\x01\x00",
1961 NULL
1962 },
1963 { NULL, 17,
1964 "\x30\x0f\x0c\x07\x68\x65\x69\x6d\x64\x61\x6c\x02\x04"
1965 "\x7f\xff\xff\xff",
1966 NULL
1967 }
1968 };
1969
1970 TESTDefault values[] = {
1971 { "Heimdal", 8, 9223372036854775807, 1 },
1972 { "heimdal", 7, 2147483647, 0 },
1973 { "Heimdal", 7, 9223372036854775807, 0 },
1974 { "heimdal", 8, 2147483647, 1 },
1975 };
1976 int i, ret;
1977 int ntests = sizeof(tests) / sizeof(*tests);
1978
1979 for (i = 0; i < ntests; ++i) {
1980 tests[i].val = &values[i];
1981 if (asprintf (&tests[i].name, "TESTDefault %d", i) < 0)
1982 errx(1, "malloc");
1983 if (tests[i].name == NULL)
1984 errx(1, "malloc");
1985 }
1986
1987 ret = generic_test (tests, ntests, sizeof(TESTDefault),
1988 (generic_encode)encode_TESTDefault,
1989 (generic_length)length_TESTDefault,
1990 (generic_decode)decode_TESTDefault,
1991 (generic_free)free_TESTDefault,
1992 cmp_default,
1993 (generic_copy)copy_TESTDefault);
1994 for (i = 0; i < ntests; ++i)
1995 free(tests[i].name);
1996
1997 return ret;
1998 }
1999
2000 static int
2001 test_x690sample(void)
2002 {
2003 /*
2004 * Taken from X.690, Appendix A, though sadly it's not specified whether
2005 * it's in BER, DER, or CER, but it is clearly BER and neither DER nor CER
2006 * because the tags of the members of the X690SamplePersonnelRecord type
2007 * are not canonically sorted in the given sample.
2008 *
2009 * Our compiler does NOT canonically sort the members of SET { ... } types
2010 * so it produces the same encoding after decoding this test vector. That
2011 * is clearly a bug given that we aim to output DER.
2012 *
2013 * The template compiler doesn't even decode SET { ... } values properly
2014 * when their members are not in the same order as defined (but the regular
2015 * compiler does).
2016 */
2017 X690SamplePersonnelRecord r;
2018 heim_octet_string os;
2019 unsigned char encoded_sample[] = {
2020 0x60, 0x81, 0x85, 0x61, 0x10, 0x1a, 0x04, 0x4a, 0x6f, 0x68, 0x6e, 0x1a,
2021 0x01, 0x50, 0x1a, 0x05, 0x53, 0x6d, 0x69, 0x74, 0x68, 0xa0, 0x0a, 0x1a,
2022 0x08, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, 0x01, 0x33,
2023 0xa1, 0x0a, 0x43, 0x08, 0x31, 0x39, 0x37, 0x31, 0x30, 0x39, 0x31, 0x37,
2024 0xa2, 0x12, 0x61, 0x10, 0x1a, 0x04, 0x4d, 0x61, 0x72, 0x79, 0x1a, 0x01,
2025 0x54, 0x1a, 0x05, 0x53, 0x6d, 0x69, 0x74, 0x68, 0xa3, 0x42, 0x31, 0x1f,
2026 0x61, 0x11, 0x1a, 0x05, 0x52, 0x61, 0x6c, 0x70, 0x68, 0x1a, 0x01, 0x54,
2027 0x1a, 0x05, 0x53, 0x6d, 0x69, 0x74, 0x68, 0xa0, 0x0a, 0x43, 0x08, 0x31,
2028 0x39, 0x35, 0x37, 0x31, 0x31, 0x31, 0x31, 0x31, 0x1f, 0x61, 0x11, 0x1a,
2029 0x05, 0x53, 0x75, 0x73, 0x61, 0x6e, 0x1a, 0x01, 0x42, 0x1a, 0x05, 0x53,
2030 0x6d, 0x69, 0x74, 0x68, 0xa0, 0x0a, 0x43, 0x08, 0x31, 0x39, 0x35, 0x39,
2031 0x30, 0x37, 0x31, 0x37
2032 };
2033 size_t sz = 0;
2034 int ret;
2035
2036 memset(&r, 0, sizeof(r));
2037 if (decode_X690SamplePersonnelRecord(encoded_sample, sizeof(encoded_sample), &r, &sz))
2038 return 1;
2039 if (sz != sizeof(encoded_sample))
2040 return 1;
2041 free_X690SamplePersonnelRecord(&r);
2042 memset(&r, 0, sizeof(r));
2043
2044 /* We re-construct the record manually to double-check the spec */
2045 r.name.givenName = strdup("John");
2046 r.name.initial = strdup("P");
2047 r.name.familyName = strdup("Smith");
2048 r.title = strdup("Director");
2049 r.dateOfHire = strdup("19710917");
2050 r.number = 51;
2051 r.nameOfSpouse.givenName = strdup("Mary");
2052 r.nameOfSpouse.initial = strdup("T");
2053 r.nameOfSpouse.familyName = strdup("Smith");
2054 r.children.val = calloc(2, sizeof(r.children.val[0]));
2055 r.children.len = 2;
2056 r.children.val[0].name.givenName = strdup("Ralph");
2057 r.children.val[0].name.initial = strdup("T");
2058 r.children.val[0].name.familyName = strdup("Smith");
2059 r.children.val[0].dateOfBirth = strdup("19571111");
2060 r.children.val[1].name.givenName = strdup("Susan");
2061 r.children.val[1].name.initial = strdup("B");
2062 r.children.val[1].name.familyName = strdup("Smith");
2063 r.children.val[1].dateOfBirth = strdup("19590717");
2064 os.length = 0;
2065 os.data = 0;
2066 ASN1_MALLOC_ENCODE(X690SamplePersonnelRecord, os.data, os.length, &r, &sz,
2067 ret);
2068 if (ret || sz != sizeof(encoded_sample) || sz != os.length ||
2069 memcmp(encoded_sample, os.data, sz) != 0)
2070 return 1;
2071 free_X690SamplePersonnelRecord(&r);
2072 free(os.data);
2073 return 0;
2074 }
2075
2076 #if ASN1_IOS_SUPPORTED
2077 static int
2078 test_ios(void)
2079 {
2080 unsigned char encoded_sample[] = {
2081 0x30, 0x82, 0x04, 0x8e, 0x30, 0x82, 0x03, 0x76,
2082 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x6a,
2083 0x05, 0x97, 0xba, 0x71, 0xd7, 0xe6, 0xd3, 0xac,
2084 0x0e, 0xdc, 0x9e, 0xdc, 0x95, 0xa1, 0x5b, 0x99,
2085 0x8d, 0xe4, 0x0a, 0x30, 0x0d, 0x06, 0x09, 0x2a,
2086 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
2087 0x05, 0x00, 0x30, 0x55, 0x31, 0x0b, 0x30, 0x09,
2088 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43,
2089 0x48, 0x31, 0x1e, 0x30, 0x1c, 0x06, 0x03, 0x55,
2090 0x04, 0x0a, 0x13, 0x15, 0x53, 0x54, 0x4d, 0x69,
2091 0x63, 0x72, 0x6f, 0x65, 0x6c, 0x65, 0x63, 0x74,
2092 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x73, 0x20, 0x4e,
2093 0x56, 0x31, 0x26, 0x30, 0x24, 0x06, 0x03, 0x55,
2094 0x04, 0x03, 0x13, 0x1d, 0x53, 0x54, 0x4d, 0x20,
2095 0x54, 0x50, 0x4d, 0x20, 0x45, 0x4b, 0x20, 0x49,
2096 0x6e, 0x74, 0x65, 0x72, 0x6d, 0x65, 0x64, 0x69,
2097 0x61, 0x74, 0x65, 0x20, 0x43, 0x41, 0x20, 0x30,
2098 0x35, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x38, 0x31,
2099 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30,
2100 0x30, 0x5a, 0x17, 0x0d, 0x32, 0x38, 0x31, 0x32,
2101 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
2102 0x5a, 0x30, 0x00, 0x30, 0x82, 0x01, 0x22, 0x30,
2103 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
2104 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82,
2105 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02,
2106 0x82, 0x01, 0x01, 0x00, 0xcc, 0x14, 0xeb, 0x27,
2107 0xa7, 0x8c, 0xeb, 0x0e, 0xa4, 0x86, 0xfa, 0x2d,
2108 0xf7, 0x83, 0x5f, 0x5f, 0xa8, 0xe9, 0x05, 0xb0,
2109 0x97, 0x01, 0x2b, 0x5b, 0xde, 0x50, 0x38, 0x0c,
2110 0x35, 0x5b, 0x1a, 0x2a, 0x72, 0x1b, 0xbc, 0x3d,
2111 0x08, 0xdd, 0x21, 0x79, 0x6c, 0xdb, 0x23, 0x9f,
2112 0xa9, 0x53, 0x10, 0x65, 0x1b, 0x1b, 0x56, 0xfd,
2113 0x2c, 0xfe, 0x53, 0xc8, 0x73, 0x52, 0xeb, 0xd9,
2114 0x96, 0xe3, 0x32, 0x56, 0x16, 0x04, 0x04, 0xce,
2115 0x93, 0x02, 0xa0, 0x80, 0x66, 0x80, 0x1e, 0x78,
2116 0x6a, 0x2f, 0x86, 0xe1, 0x81, 0xf9, 0x49, 0x96,
2117 0x6f, 0x49, 0x2a, 0x85, 0xb5, 0x8e, 0xaa, 0x4a,
2118 0x6a, 0x8c, 0xb3, 0x69, 0x75, 0x51, 0xbb, 0x23,
2119 0x6e, 0x87, 0xcc, 0x7b, 0xf8, 0xec, 0x13, 0x47,
2120 0x87, 0x1c, 0x91, 0xe1, 0x54, 0x37, 0xe8, 0xf2,
2121 0x66, 0xbf, 0x1e, 0xa5, 0xeb, 0x27, 0x1f, 0xdc,
2122 0xf3, 0x74, 0xd8, 0xb4, 0x7d, 0xf8, 0xbc, 0xe8,
2123 0x9e, 0x1f, 0xad, 0x61, 0xc2, 0xa0, 0x88, 0xcb,
2124 0x40, 0x36, 0xb3, 0x59, 0xcb, 0x72, 0xa2, 0x94,
2125 0x97, 0x3f, 0xed, 0xcc, 0xf0, 0xc3, 0x40, 0xaf,
2126 0xfd, 0x14, 0xb6, 0x4f, 0x04, 0x11, 0x65, 0x58,
2127 0x1a, 0xca, 0x34, 0x14, 0x7c, 0x1c, 0x75, 0x61,
2128 0x70, 0x47, 0x05, 0x8f, 0x7e, 0xd7, 0xd6, 0x03,
2129 0xe0, 0x32, 0x50, 0x80, 0x94, 0xfa, 0x73, 0xe8,
2130 0xb9, 0x15, 0x3d, 0xa3, 0xbf, 0x25, 0x5d, 0x2c,
2131 0xbb, 0xc5, 0xdf, 0x30, 0x1b, 0xa8, 0xf7, 0x4d,
2132 0x19, 0x8b, 0xeb, 0xce, 0x86, 0x04, 0x0f, 0xc1,
2133 0xd2, 0x92, 0x7c, 0x76, 0x57, 0x41, 0x44, 0x90,
2134 0xd8, 0x02, 0xf4, 0x82, 0xf3, 0xeb, 0xf2, 0xde,
2135 0x35, 0xee, 0x14, 0x9a, 0x1a, 0x6d, 0xe8, 0xd1,
2136 0x68, 0x91, 0xfb, 0xfb, 0xa0, 0x2a, 0x18, 0xaf,
2137 0xe5, 0x9f, 0x9d, 0x6f, 0x14, 0x97, 0x44, 0xe5,
2138 0xf0, 0xd5, 0x59, 0xb1, 0x02, 0x03, 0x01, 0x00,
2139 0x01, 0xa3, 0x82, 0x01, 0xa9, 0x30, 0x82, 0x01,
2140 0xa5, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23,
2141 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x1a, 0xdb,
2142 0x99, 0x4a, 0xb5, 0x8b, 0xe5, 0x7a, 0x0c, 0xc9,
2143 0xb9, 0x00, 0xe7, 0x85, 0x1e, 0x1a, 0x43, 0xc0,
2144 0x86, 0x60, 0x30, 0x42, 0x06, 0x03, 0x55, 0x1d,
2145 0x20, 0x04, 0x3b, 0x30, 0x39, 0x30, 0x37, 0x06,
2146 0x04, 0x55, 0x1d, 0x20, 0x00, 0x30, 0x2f, 0x30,
2147 0x2d, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05,
2148 0x07, 0x02, 0x01, 0x16, 0x21, 0x68, 0x74, 0x74,
2149 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
2150 0x73, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x54,
2151 0x50, 0x4d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73,
2152 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x30, 0x59,
2153 0x06, 0x03, 0x55, 0x1d, 0x11, 0x01, 0x01, 0xff,
2154 0x04, 0x4f, 0x30, 0x4d, 0xa4, 0x4b, 0x30, 0x49,
2155 0x31, 0x16, 0x30, 0x14, 0x06, 0x05, 0x67, 0x81,
2156 0x05, 0x02, 0x01, 0x0c, 0x0b, 0x69, 0x64, 0x3a,
2157 0x35, 0x33, 0x35, 0x34, 0x34, 0x44, 0x32, 0x30,
2158 0x31, 0x17, 0x30, 0x15, 0x06, 0x05, 0x67, 0x81,
2159 0x05, 0x02, 0x02, 0x0c, 0x0c, 0x53, 0x54, 0x33,
2160 0x33, 0x48, 0x54, 0x50, 0x48, 0x41, 0x48, 0x43,
2161 0x30, 0x31, 0x16, 0x30, 0x14, 0x06, 0x05, 0x67,
2162 0x81, 0x05, 0x02, 0x03, 0x0c, 0x0b, 0x69, 0x64,
2163 0x3a, 0x30, 0x30, 0x34, 0x39, 0x30, 0x30, 0x30,
2164 0x38, 0x30, 0x67, 0x06, 0x03, 0x55, 0x1d, 0x09,
2165 0x04, 0x60, 0x30, 0x5e, 0x30, 0x17, 0x06, 0x05,
2166 0x67, 0x81, 0x05, 0x02, 0x10, 0x31, 0x0e, 0x30,
2167 0x0c, 0x0c, 0x03, 0x32, 0x2e, 0x30, 0x02, 0x01,
2168 0x00, 0x02, 0x02, 0x00, 0x8a, 0x30, 0x43, 0x06,
2169 0x05, 0x67, 0x81, 0x05, 0x02, 0x12, 0x31, 0x3a,
2170 0x30, 0x38, 0x02, 0x01, 0x00, 0x01, 0x01, 0xff,
2171 0xa0, 0x03, 0x0a, 0x01, 0x01, 0xa1, 0x03, 0x0a,
2172 0x01, 0x00, 0xa2, 0x03, 0x0a, 0x01, 0x00, 0xa3,
2173 0x10, 0x30, 0x0e, 0x16, 0x03, 0x33, 0x2e, 0x31,
2174 0x0a, 0x01, 0x04, 0x0a, 0x01, 0x02, 0x01, 0x01,
2175 0xff, 0xa4, 0x0f, 0x30, 0x0d, 0x16, 0x05, 0x31,
2176 0x34, 0x30, 0x2d, 0x32, 0x0a, 0x01, 0x02, 0x01,
2177 0x01, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d,
2178 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02,
2179 0x05, 0x20, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d,
2180 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00,
2181 0x30, 0x10, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04,
2182 0x09, 0x30, 0x07, 0x06, 0x05, 0x67, 0x81, 0x05,
2183 0x08, 0x01, 0x30, 0x4a, 0x06, 0x08, 0x2b, 0x06,
2184 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x3e,
2185 0x30, 0x3c, 0x30, 0x3a, 0x06, 0x08, 0x2b, 0x06,
2186 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x2e,
2187 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73,
2188 0x65, 0x63, 0x75, 0x72, 0x65, 0x2e, 0x67, 0x6c,
2189 0x6f, 0x62, 0x61, 0x6c, 0x73, 0x69, 0x67, 0x6e,
2190 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x6d,
2191 0x74, 0x70, 0x6d, 0x65, 0x6b, 0x69, 0x6e, 0x74,
2192 0x30, 0x35, 0x2e, 0x63, 0x72, 0x74, 0x30, 0x0d,
2193 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
2194 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01,
2195 0x01, 0x00, 0x3d, 0x4c, 0x38, 0x1e, 0x5b, 0x4f,
2196 0x1b, 0xcb, 0xe0, 0x9c, 0x63, 0xd5, 0x2f, 0x1f,
2197 0x04, 0x57, 0x0c, 0xae, 0xa1, 0x42, 0xfd, 0x9c,
2198 0xd9, 0x42, 0x04, 0x3b, 0x11, 0xf8, 0xe3, 0xbd,
2199 0xcf, 0x50, 0x00, 0x7a, 0xe1, 0x6c, 0xf8, 0x86,
2200 0x90, 0x13, 0x04, 0x1e, 0x92, 0xcd, 0xd3, 0x28,
2201 0x0b, 0xa4, 0xb5, 0x1f, 0xbb, 0xd4, 0x05, 0x82,
2202 0xed, 0x75, 0x02, 0x19, 0xe2, 0x61, 0xa6, 0x95,
2203 0x09, 0x56, 0x74, 0x85, 0x5a, 0xac, 0xeb, 0x52,
2204 0x0a, 0xda, 0xff, 0x9e, 0x7e, 0x90, 0x84, 0x80,
2205 0xa3, 0x9c, 0xdc, 0xf9, 0x00, 0x46, 0x2d, 0x91,
2206 0x71, 0x96, 0x0f, 0xfe, 0x55, 0xd3, 0xac, 0x49,
2207 0xe8, 0xc9, 0x81, 0x34, 0x1b, 0xbd, 0x2e, 0xfb,
2208 0xcc, 0x25, 0x2a, 0x4c, 0x18, 0xa4, 0xf3, 0xb7,
2209 0xc8, 0x4c, 0xce, 0x42, 0xce, 0x70, 0xa2, 0x08,
2210 0xc8, 0x4d, 0x26, 0x30, 0xa7, 0xab, 0xfb, 0xe7,
2211 0x2d, 0x62, 0x71, 0xe7, 0x5b, 0x9f, 0xf1, 0xc9,
2212 0x71, 0xd2, 0x0e, 0xb3, 0xdb, 0xd7, 0x63, 0xf1,
2213 0xe0, 0x4d, 0x83, 0x4e, 0xaa, 0x69, 0x2d, 0x2e,
2214 0x40, 0x01, 0xbb, 0xf4, 0x73, 0x0a, 0x3e, 0x3f,
2215 0xda, 0x97, 0x11, 0xae, 0x38, 0x65, 0x24, 0xd9,
2216 0x1c, 0x63, 0xbe, 0x0e, 0x51, 0x6d, 0x00, 0xd5,
2217 0xc6, 0x14, 0x1f, 0xcc, 0xf6, 0xc5, 0x39, 0xf3,
2218 0x51, 0x8e, 0x18, 0x00, 0x49, 0x86, 0x5b, 0xe1,
2219 0x6b, 0x69, 0xca, 0xe1, 0xf8, 0xcb, 0x7f, 0xdc,
2220 0x47, 0x4b, 0x38, 0xf7, 0xee, 0x56, 0xcb, 0xe7,
2221 0xd8, 0xa8, 0x9d, 0x9b, 0xa9, 0x9b, 0x65, 0xd5,
2222 0x26, 0x5a, 0xef, 0x32, 0xaa, 0x62, 0x42, 0x6b,
2223 0x10, 0xe6, 0xd7, 0x5b, 0xb8, 0x67, 0x7e, 0xc4,
2224 0x4f, 0x75, 0x5b, 0xbc, 0x28, 0x06, 0xfd, 0x2b,
2225 0x4e, 0x04, 0xbd, 0xf5, 0xd4, 0x42, 0x59, 0xdb,
2226 0xea, 0xa4, 0x2b, 0x6f, 0x56, 0x3d, 0xf7, 0xaa,
2227 0x75, 0x06,
2228 };
2229 char cert_json[] = {
2230 "{\"_type\":\"Certificate\",\"tbsCertificate\":{\"_type\":\"TBSCertificate"
2231 "\",\"_save\":\"30820376A00302010202146A0597BA71D7E6D3AC0EDC9EDC95A15"
2232 "B998DE40A300D06092A864886F70D01010B05003055310B30090603550406130"
2233 "24348311E301C060355040A131553544D6963726F656C656374726F6E6963732"
2234 "04E56312630240603550403131D53544D2054504D20454B20496E7465726D656"
2235 "469617465204341203035301E170D3138313231343030303030305A170D32383"
2236 "13231343030303030305A300030820122300D06092A864886F70D01010105000"
2237 "382010F003082010A0282010100CC14EB27A78CEB0EA486FA2DF7835F5FA8E90"
2238 "5B097012B5BDE50380C355B1A2A721BBC3D08DD21796CDB239FA95310651B1B5"
2239 "6FD2CFE53C87352EBD996E33256160404CE9302A08066801E786A2F86E181F94"
2240 "9966F492A85B58EAA4A6A8CB3697551BB236E87CC7BF8EC1347871C91E15437E"
2241 "8F266BF1EA5EB271FDCF374D8B47DF8BCE89E1FAD61C2A088CB4036B359CB72A"
2242 "294973FEDCCF0C340AFFD14B64F041165581ACA34147C1C75617047058F7ED7D"
2243 "603E032508094FA73E8B9153DA3BF255D2CBBC5DF301BA8F74D198BEBCE86040"
2244 "FC1D2927C7657414490D802F482F3EBF2DE35EE149A1A6DE8D16891FBFBA02A1"
2245 "8AFE59F9D6F149744E5F0D559B10203010001A38201A9308201A5301F0603551"
2246 "D230418301680141ADB994AB58BE57A0CC9B900E7851E1A43C08660304206035"
2247 "51D20043B303930370604551D2000302F302D06082B060105050702011621687"
2248 "474703A2F2F7777772E73742E636F6D2F54504D2F7265706F7369746F72792F3"
2249 "0590603551D110101FF044F304DA44B304931163014060567810502010C0B696"
2250 "43A353335343444323031173015060567810502020C0C5354333348545048414"
2251 "8433031163014060567810502030C0B69643A303034393030303830670603551"
2252 "D090460305E301706056781050210310E300C0C03322E300201000202008A304"
2253 "306056781050212313A30380201000101FFA0030A0101A1030A0100A2030A010"
2254 "0A310300E1603332E310A01040A01020101FFA40F300D16053134302D320A010"
2255 "2010100300E0603551D0F0101FF040403020520300C0603551D130101FF04023"
2256 "00030100603551D250409300706056781050801304A06082B060105050701010"
2257 "43E303C303A06082B06010505073002862E687474703A2F2F7365637572652E6"
2258 "76C6F62616C7369676E2E636F6D2F73746D74706D656B696E7430352E637274\""
2259 ",\"version\":\"rfc3280_version_3\",\"serialNumber\":\"6A0597BA71D7E6D3A"
2260 "C0EDC9EDC95A15B998DE40A\",\"signature\":{\"_type\":\"AlgorithmIdentifi"
2261 "er\",\"algorithm\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"1.2.840.1135"
2262 "49.1.1.11\",\"components\":[1,2,840,113549,1,1,11],\"name\":\"id-pkcs1"
2263 "-sha256WithRSAEncryption\"},\"parameters\":\"0500\"},\"issuer\":{\"_choi"
2264 "ce\":\"rdnSequence\",\"value\":[[{\"_type\":\"AttributeTypeAndValue\",\"ty"
2265 "pe\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.4.6\",\"components\":[2"
2266 ",5,4,6],\"name\":\"id-at-countryName\"},\"value\":{\"_choice\":\"printabl"
2267 "eString\",\"value\":\"CH\"}}],[{\"_type\":\"AttributeTypeAndValue\",\"type"
2268 "\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.4.10\",\"components\":[2,"
2269 "5,4,10],\"name\":\"id-at-organizationName\"},\"value\":{\"_choice\":\"pri"
2270 "ntableString\",\"value\":\"STMicroelectronics NV\"}}],[{\"_type\":\"Attr"
2271 "ibuteTypeAndValue\",\"type\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2."
2272 "5.4.3\",\"components\":[2,5,4,3],\"name\":\"id-at-commonName\"},\"value\""
2273 ":{\"_choice\":\"printableString\",\"value\":\"STM TPM EK Intermediate C"
2274 "A 05\"}}]]},\"validity\":{\"_type\":\"Validity\",\"notBefore\":{\"_choice\""
2275 ":\"utcTime\",\"value\":\"2018-12-14T00:00:00Z\"},\"notAfter\":{\"_choice\""
2276 ":\"utcTime\",\"value\":\"2028-12-14T00:00:00Z\"}},\"subject\":{\"_choice\""
2277 ":\"rdnSequence\",\"value\":[]},\"subjectPublicKeyInfo\":{\"_type\":\"Subj"
2278 "ectPublicKeyInfo\",\"algorithm\":{\"_type\":\"AlgorithmIdentifier\",\"al"
2279 "gorithm\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"1.2.840.113549.1.1."
2280 "1\",\"components\":[1,2,840,113549,1,1,1],\"name\":\"id-pkcs1-rsaEncry"
2281 "ption\"},\"parameters\":\"0500\"},\"subjectPublicKey\":\"2160:3082010A02"
2282 "82010100CC14EB27A78CEB0EA486FA2DF7835F5FA8E905B097012B5BDE50380C"
2283 "355B1A2A721BBC3D08DD21796CDB239FA95310651B1B56FD2CFE53C87352EBD9"
2284 "96E33256160404CE9302A08066801E786A2F86E181F949966F492A85B58EAA4A"
2285 "6A8CB3697551BB236E87CC7BF8EC1347871C91E15437E8F266BF1EA5EB271FDC"
2286 "F374D8B47DF8BCE89E1FAD61C2A088CB4036B359CB72A294973FEDCCF0C340AF"
2287 "FD14B64F041165581ACA34147C1C75617047058F7ED7D603E032508094FA73E8"
2288 "B9153DA3BF255D2CBBC5DF301BA8F74D198BEBCE86040FC1D2927C7657414490"
2289 "D802F482F3EBF2DE35EE149A1A6DE8D16891FBFBA02A18AFE59F9D6F149744E5"
2290 "F0D559B10203010001\"},\"issuerUniqueID\":null,\"subjectUniqueID\":nul"
2291 "l,\"extensions\":[{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT I"
2292 "DENTIFIER\",\"oid\":\"2.5.29.35\",\"components\":[2,5,29,35],\"name\":\"id"
2293 "-x509-ce-authorityKeyIdentifier\"},\"critical\":false,\"extnValue\":\""
2294 "301680141ADB994AB58BE57A0CC9B900E7851E1A43C08660\",\"_extnValue_ch"
2295 "oice\":\"ext-AuthorityKeyIdentifier\",\"_extnValue\":{\"_type\":\"Author"
2296 "ityKeyIdentifier\",\"keyIdentifier\":\"1ADB994AB58BE57A0CC9B900E7851"
2297 "E1A43C08660\",\"authorityCertIssuer\":null,\"authorityCertSerialNumb"
2298 "er\":null}},{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENTI"
2299 "FIER\",\"oid\":\"2.5.29.32\",\"components\":[2,5,29,32],\"name\":\"id-x509"
2300 "-ce-certificatePolicies\"},\"critical\":false,\"extnValue\":\"30393037"
2301 "0604551D2000302F302D06082B060105050702011621687474703A2F2F777777"
2302 "2E73742E636F6D2F54504D2F7265706F7369746F72792F\",\"_extnValue_choi"
2303 "ce\":\"ext-CertificatePolicies\",\"_extnValue\":[{\"_type\":\"PolicyInfo"
2304 "rmation\",\"policyIdentifier\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\""
2305 "2.5.29.32.0\",\"components\":[2,5,29,32,0],\"name\":\"id-x509-ce-certi"
2306 "ficatePolicies-anyPolicy\"},\"policyQualifiers\":[{\"_type\":\"PolicyQ"
2307 "ualifierInfo\",\"policyQualifierId\":{\"_type\":\"OBJECT IDENTIFIER\",\""
2308 "oid\":\"1.3.6.1.5.5.7.2.1\",\"components\":[1,3,6,1,5,5,7,2,1],\"name\""
2309 ":\"id-pkix-qt-cps\"},\"qualifier\":\"1621687474703A2F2F7777772E73742E"
2310 "636F6D2F54504D2F7265706F7369746F72792F\",\"_qualifier_choice\":\"pq-"
2311 "CPS\"}]}]},{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENTIF"
2312 "IER\",\"oid\":\"2.5.29.17\",\"components\":[2,5,29,17],\"name\":\"id-x509-"
2313 "ce-subjectAltName\"},\"critical\":true,\"extnValue\":\"304DA44B3049311"
2314 "63014060567810502010C0B69643A35333534344432303117301506056781050"
2315 "2020C0C53543333485450484148433031163014060567810502030C0B69643A3"
2316 "030343930303038\",\"_extnValue_choice\":\"ext-SubjectAltName\",\"_extn"
2317 "Value\":[{\"_choice\":\"directoryName\",\"value\":{\"_choice\":\"rdnSequen"
2318 "ce\",\"value\":[[{\"_type\":\"AttributeTypeAndValue\",\"type\":{\"_type\":\""
2319 "OBJECT IDENTIFIER\",\"oid\":\"2.23.133.2.1\",\"components\":[2,23,133,2"
2320 ",1],\"name\":\"tcg-at-tpmManufacturer\"},\"value\":{\"_choice\":\"utf8Str"
2321 "ing\",\"value\":\"id:53544D20\"}}],[{\"_type\":\"AttributeTypeAndValue\","
2322 "\"type\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.23.133.2.2\",\"compon"
2323 "ents\":[2,23,133,2,2],\"name\":\"tcg-at-tpmModel\"},\"value\":{\"_choice"
2324 "\":\"utf8String\",\"value\":\"ST33HTPHAHC0\"}}],[{\"_type\":\"AttributeTyp"
2325 "eAndValue\",\"type\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.23.133.2"
2326 ".3\",\"components\":[2,23,133,2,3],\"name\":\"tcg-at-tpmVersion\"},\"val"
2327 "ue\":{\"_choice\":\"utf8String\",\"value\":\"id:00490008\"}}]]}}]},{\"_typ"
2328 "e\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5."
2329 "29.9\",\"components\":[2,5,29,9],\"name\":\"id-x509-ce-subjectDirector"
2330 "yAttributes\"},\"critical\":false,\"extnValue\":\"305E3017060567810502"
2331 "10310E300C0C03322E300201000202008A304306056781050212313A30380201"
2332 "000101FFA0030A0101A1030A0100A2030A0100A310300E1603332E310A01040A"
2333 "01020101FFA40F300D16053134302D320A0102010100\",\"_extnValue_choice"
2334 "\":\"ext-SubjectDirectoryAttributes\",\"_extnValue\":[{\"_type\":\"Attri"
2335 "buteSet\",\"type\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.23.133.2.1"
2336 "6\",\"components\":[2,23,133,2,16],\"name\":\"tcg-at-tpmSpecification\""
2337 "},\"values\":[\"300C0C03322E300201000202008A\"],\"_values_choice\":\"at"
2338 "-TPMSpecification\",\"_values\":[{\"_type\":\"TPMSpecification\",\"famil"
2339 "y\":\"2.0\",\"level\":0,\"revision\":138}]},{\"_type\":\"AttributeSet\",\"ty"
2340 "pe\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.23.133.2.18\",\"componen"
2341 "ts\":[2,23,133,2,18],\"name\":\"tcg-at-tpmSecurityAssertions\"},\"valu"
2342 "es\":[\"30380201000101FFA0030A0101A1030A0100A2030A0100A310300E1603"
2343 "332E310A01040A01020101FFA40F300D16053134302D320A0102010100\"],\"_v"
2344 "alues_choice\":\"at-TPMSecurityAssertions\",\"_values\":[{\"_type\":\"TP"
2345 "MSecurityAssertions\",\"version\":0,\"fieldUpgradable\":true,\"ekGener"
2346 "ationType\":\"ekgt-injected\",\"ekGenerationLocation\":\"tpmManufactur"
2347 "er\",\"ekCertificateGenerationLocation\":\"tpmManufacturer\",\"ccInfo\""
2348 ":{\"_type\":\"CommonCriteriaMeasures\",\"version\":\"3.1\",\"assurancelev"
2349 "el\":\"ealevel4\",\"evaluationStatus\":\"evaluationCompleted\",\"plus\":t"
2350 "rue,\"strengthOfFunction\":null,\"profileOid\":null,\"profileUri\":nul"
2351 "l,\"targetOid\":null,\"targetUri\":null},\"fipsLevel\":{\"_type\":\"FIPSL"
2352 "evel\",\"version\":\"140-2\",\"level\":\"sllevel2\",\"plus\":false},\"iso900"
2353 "0Certified\":false,\"iso9000Uri\":null}]}]},{\"_type\":\"Extension\",\"e"
2354 "xtnID\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.29.15\",\"component"
2355 "s\":[2,5,29,15],\"name\":\"id-x509-ce-keyUsage\"},\"critical\":true,\"ex"
2356 "tnValue\":\"03020520\",\"_extnValue_choice\":\"ext-KeyUsage\",\"_extnVal"
2357 "ue\":[\"keyEncipherment\"]},{\"_type\":\"Extension\",\"extnID\":{\"_type\":"
2358 "\"OBJECT IDENTIFIER\",\"oid\":\"2.5.29.19\",\"components\":[2,5,29,19],\""
2359 "name\":\"id-x509-ce-basicConstraints\"},\"critical\":true,\"extnValue\""
2360 ":\"3000\",\"_extnValue_choice\":\"ext-BasicConstraints\",\"_extnValue\":"
2361 "{\"_type\":\"BasicConstraints\",\"cA\":false,\"pathLenConstraint\":null}"
2362 "},{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENTIFIER\",\"oi"
2363 "d\":\"2.5.29.37\",\"components\":[2,5,29,37],\"name\":\"id-x509-ce-extKe"
2364 "yUsage\"},\"critical\":false,\"extnValue\":\"300706056781050801\",\"_ext"
2365 "nValue_choice\":\"ext-ExtKeyUsage\",\"_extnValue\":[{\"_type\":\"OBJECT "
2366 "IDENTIFIER\",\"oid\":\"2.23.133.8.1\",\"components\":[2,23,133,8,1],\"na"
2367 "me\":\"tcg-kp-EKCertificate\"}]},{\"_type\":\"Extension\",\"extnID\":{\"_t"
2368 "ype\":\"OBJECT IDENTIFIER\",\"oid\":\"1.3.6.1.5.5.7.1.1\",\"components\":"
2369 "[1,3,6,1,5,5,7,1,1],\"name\":\"id-pkix-pe-authorityInfoAccess\"},\"cr"
2370 "itical\":false,\"extnValue\":\"303C303A06082B06010505073002862E68747"
2371 "4703A2F2F7365637572652E676C6F62616C7369676E2E636F6D2F73746D74706"
2372 "D656B696E7430352E637274\",\"_extnValue_choice\":\"ext-AuthorityInfoA"
2373 "ccess\",\"_extnValue\":[{\"_type\":\"AccessDescription\",\"accessMethod\""
2374 ":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"1.3.6.1.5.5.7.48.2\",\"compon"
2375 "ents\":[1,3,6,1,5,5,7,48,2],\"name\":\"id-pkix-ad-caIssuers\"},\"acces"
2376 "sLocation\":{\"_choice\":\"uniformResourceIdentifier\",\"value\":\"http:"
2377 "//secure.globalsign.com/stmtpmekint05.crt\"}}]}]},\"signatureAlgor"
2378 "ithm\":{\"_type\":\"AlgorithmIdentifier\",\"algorithm\":{\"_type\":\"OBJEC"
2379 "T IDENTIFIER\",\"oid\":\"1.2.840.113549.1.1.11\",\"components\":[1,2,84"
2380 "0,113549,1,1,11],\"name\":\"id-pkcs1-sha256WithRSAEncryption\"},\"par"
2381 "ameters\":\"0500\"},\"signatureValue\":\"2048:3D4C381E5B4F1BCBE09C63D5"
2382 "2F1F04570CAEA142FD9CD942043B11F8E3BDCF50007AE16CF8869013041E92CD"
2383 "D3280BA4B51FBBD40582ED750219E261A695095674855AACEB520ADAFF9E7E90"
2384 "8480A39CDCF900462D9171960FFE55D3AC49E8C981341BBD2EFBCC252A4C18A4"
2385 "F3B7C84CCE42CE70A208C84D2630A7ABFBE72D6271E75B9FF1C971D20EB3DBD7"
2386 "63F1E04D834EAA692D2E4001BBF4730A3E3FDA9711AE386524D91C63BE0E516D"
2387 "00D5C6141FCCF6C539F3518E180049865BE16B69CAE1F8CB7FDC474B38F7EE56"
2388 "CBE7D8A89D9BA99B65D5265AEF32AA62426B10E6D75BB8677EC44F755BBC2806"
2389 "FD2B4E04BDF5D44259DBEAA42B6F563DF7AA7506\""
2390 "}"
2391 };
2392 heim_octet_string os;
2393 Certificate c0, c1;
2394 size_t i, nknown, size;
2395 char *s;
2396 int ret;
2397
2398 /*
2399 * Test automatic decoding of open types.
2400 *
2401 * Decode a value that has plenty of open types with values of known
2402 * alternatives in them, then check that we got what we wanted.
2403 */
2404 ret = decode_Certificate(encoded_sample, sizeof(encoded_sample),
2405 &c0, &size);
2406 if (ret)
2407 return 1;
2408 if (size != sizeof(encoded_sample))
2409 return 1;
2410
2411 s = print_Certificate(&c0, 0);
2412 if (!s)
2413 return 1;
2414 if (strcmp(s, cert_json) != 0)
2415 return 1;
2416 free(s);
2417
2418 ret = copy_Certificate(&c0, &c1);
2419 if (ret)
2420 return 1;
2421
2422 if (!c0.tbsCertificate.extensions || !c1.tbsCertificate.extensions)
2423 return 1;
2424 if (!c0.tbsCertificate.extensions->len ||
2425 c0.tbsCertificate.extensions->len != c1.tbsCertificate.extensions->len)
2426 return 1;
2427 for (i = nknown = 0; i < c0.tbsCertificate.extensions->len; i++) {
2428 if (c0.tbsCertificate.extensions->val[i]._ioschoice_extnValue.element !=
2429 c1.tbsCertificate.extensions->val[i]._ioschoice_extnValue.element)
2430 return 1;
2431 if (c0.tbsCertificate.extensions->val[i]._ioschoice_extnValue.element) {
2432 #if 0
2433 fprintf(stderr, "extension %llu known %u\n",
2434 (unsigned long long)i,
2435 c0.tbsCertificate.extensions->val[i]._ioschoice_extnValue._element);
2436 #endif
2437 nknown++;
2438 }
2439 }
2440 if (!nknown)
2441 return 1;
2442
2443
2444 /*
2445 * Check that this round trips. But note that this attempt to encode will
2446 * ignore the automatically decoded open type values from above because
2447 * their encodings are still present.
2448 */
2449 ASN1_MALLOC_ENCODE(Certificate, os.data, os.length, &c1, &size, ret);
2450 if (ret)
2451 return 1;
2452 if (os.length != size || size != sizeof(encoded_sample))
2453 return 1;
2454 if (memcmp(os.data, encoded_sample, os.length) != 0)
2455 return 1;
2456 der_free_octet_string(&os);
2457
2458 /*
2459 * Test automatic encoding of open types by clearing the encoding of one
2460 * such open type value, forcing the encoder to encode the value from
2461 * before.
2462 */
2463 der_free_octet_string(&c0.tbsCertificate.extensions->val[0].extnValue);
2464 der_free_oid(&c0.tbsCertificate.extensions->val[0].extnID);
2465
2466 ASN1_MALLOC_ENCODE(Certificate, os.data, os.length, &c0, &size, ret);
2467 if (ret)
2468 return 1;
2469 if (os.length != size || size != sizeof(encoded_sample))
2470 return 1;
2471 if (memcmp(os.data, encoded_sample, os.length) != 0)
2472 return 1;
2473 der_free_octet_string(&os);
2474
2475 /*
2476 * Repeat, but with the copy, as this will test that copying data
2477 * structures with decoded open types in them also copies those.
2478 */
2479 der_free_octet_string(&c1.tbsCertificate.extensions->val[0].extnValue);
2480 der_free_oid(&c1.tbsCertificate.extensions->val[0].extnID);
2481
2482 ASN1_MALLOC_ENCODE(Certificate, os.data, os.length, &c1, &size, ret);
2483 if (ret)
2484 return 1;
2485 if (os.length != size || size != sizeof(encoded_sample))
2486 return 1;
2487 if (memcmp(os.data, encoded_sample, os.length) != 0)
2488 return 1;
2489 der_free_octet_string(&os);
2490
2491 free_Certificate(&c0);
2492 free_Certificate(&c1);
2493 return 0;
2494 }
2495 #endif
2496
2497 int
2498 main(int argc, char **argv)
2499 {
2500 int ret = 0;
2501
2502 #define DO_ONE(t) if (t()) { fprintf(stderr, "%s() failed!\n", #t); ret++; }
2503 DO_ONE(test_principal);
2504 DO_ONE(test_authenticator);
2505 DO_ONE(test_krb_error);
2506 DO_ONE(test_Name);
2507 DO_ONE(test_bit_string);
2508 DO_ONE(test_bit_string_rfc1510);
2509 DO_ONE(test_time);
2510 DO_ONE(test_cert);
2511
2512 DO_ONE(check_tag_length);
2513 DO_ONE(check_tag_length64);
2514 DO_ONE(check_tag_length64s);
2515 DO_ONE(test_large_tag);
2516 DO_ONE(test_choice);
2517
2518 DO_ONE(test_implicit);
2519
2520 DO_ONE(test_taglessalloc);
2521 DO_ONE(test_optional);
2522
2523 DO_ONE(check_fail_largetag);
2524 DO_ONE(check_fail_sequence);
2525 DO_ONE(check_fail_choice);
2526 DO_ONE(check_fail_Ticket);
2527
2528 DO_ONE(check_seq);
2529 DO_ONE(check_seq_of_size);
2530 DO_ONE(test_SignedData);
2531
2532 DO_ONE(check_TESTMechTypeList);
2533 DO_ONE(test_seq4);
2534 DO_ONE(test_seqof5);
2535
2536 DO_ONE(test_x690sample);
2537
2538 DO_ONE(test_default);
2539
2540 DO_ONE(test_decorated);
2541
2542 #if ASN1_IOS_SUPPORTED
2543 DO_ONE(test_ios);
2544 #endif
2545
2546 return ret;
2547 }
Samba GIT mirror