?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gss: pass GSS_C_NO_OID name type through to mechanism
[heimdal.git] / lib / asn1 / check-template.c
blob21132c8d1a4d3d38f1046d8c2c5214b0410f1fba
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
38 #include <stdio.h>
39 #include <string.h>
40 #include <err.h>
41 #include <roken.h>
42
43 #include <asn1-common.h>
44 #include <asn1_err.h>
45 #include <der.h>
46 #include <test_asn1.h>
47
48 #include "check-common.h"
49 #include "der_locl.h"
50
51 static int
52 cmp_dummy (void *a, void *b)
53 {
54 return 0;
55 }
56
57 static int
58 test_uint64(void)
59 {
60 struct test_case tests[] = {
61 { NULL, 3, "\x02\x01\x00", "uint64 0" },
62 { NULL, 7, "\x02\x05\x01\xff\xff\xff\xff", "uint64 1" },
63 { NULL, 7, "\x02\x05\x02\x00\x00\x00\x00", "uint64 2" },
64 { NULL, 9, "\x02\x07\x7f\xff\xff\xff\xff\xff\xff", "uint64 3" },
65 { NULL, 10, "\x02\x08\x00\x80\x00\x00\x00\x00\x00\x00", "uint64 4" },
66 { NULL, 10, "\x02\x08\x7f\xff\xff\xff\xff\xff\xff\xff", "uint64 5" },
67 { NULL, 11, "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff", "uint64 6" }
68 };
69
70 size_t i;
71 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
72 TESTuint64 values[] = { 0, 8589934591LL, 8589934592LL,
73 36028797018963967LL, 36028797018963968LL,
74 9223372036854775807LL, 18446744073709551615ULL };
75
76 for (i = 0; i < ntests; i++)
77 tests[i].val = &values[i];
78
79 if (sizeof(TESTuint64) != sizeof(uint64_t)) {
80 ret += 1;
81 printf("sizeof(TESTuint64) %d != sizeof(uint64_t) %d\n",
82 (int)sizeof(TESTuint64), (int)sizeof(uint64_t));
83 }
84
85 ret += generic_test (tests, ntests, sizeof(TESTuint64),
86 (generic_encode)encode_TESTuint64,
87 (generic_length)length_TESTuint64,
88 (generic_decode)decode_TESTuint64,
89 (generic_free)free_TESTuint64,
90 cmp_dummy,
91 NULL);
92 return ret;
93 }
94
95 static int
96 test_seqofseq(void)
97 {
98 struct test_case tests[] = {
99 { NULL, 2,
100 "\x30\x00",
101 "seqofseq 0" },
102 { NULL, 9,
103 "\x30\x07\x30\x05\xa0\x03\x02\x01\x00",
104 "seqofseq 1" },
105 { NULL, 16,
106 "\x30\x0e\x30\x05\xa0\x03\x02\x01\x00\x30\x05\xa0\x03\x02\x01\x01",
107 "seqofseq 2" }
108 };
109
110 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
111 TESTSeqOfSeq c0, c1, c2;
112 struct TESTSeqOfSeq_val i[2];
113
114 i[0].zero = 0;
115 i[1].zero = 1;
116
117 c0.len = 0;
118 c0.val = NULL;
119 tests[0].val = &c0;
120
121 c1.len = 1;
122 c1.val = i;
123 tests[1].val = &c1;
124
125 c2.len = 2;
126 c2.val = i;
127 tests[2].val = &c2;
128
129 ret += generic_test (tests, ntests, sizeof(TESTSeqOfSeq),
130 (generic_encode)encode_TESTSeqOfSeq,
131 (generic_length)length_TESTSeqOfSeq,
132 (generic_decode)decode_TESTSeqOfSeq,
133 (generic_free)free_TESTSeqOfSeq,
134 cmp_dummy,
135 NULL);
136 return ret;
137 }
138
139 static int
140 test_seqofseq2(void)
141 {
142 struct test_case tests[] = {
143 { NULL, 2,
144 "\x30\x00",
145 "seqofseq2 0" },
146 { NULL, 11,
147 "\x30\x09\x30\x07\xa0\x05\x1b\x03\x65\x74\x74",
148 "seqofseq2 1" },
149 { NULL, 21,
150 "\x30\x13\x30\x07\xa0\x05\x1b\x03\x65\x74\x74\x30\x08\xa0"
151 "\x06\x1b\x04\x74\x76\x61\x61",
152 "seqofseq2 2" }
153 };
154
155 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
156 TESTSeqOfSeq2 c0, c1, c2;
157 struct TESTSeqOfSeq2_val i[2];
158
159 i[0].string = "ett";
160 i[1].string = "tvaa";
161
162 c0.len = 0;
163 c0.val = NULL;
164 tests[0].val = &c0;
165
166 c1.len = 1;
167 c1.val = i;
168 tests[1].val = &c1;
169
170 c2.len = 2;
171 c2.val = i;
172 tests[2].val = &c2;
173
174 ret += generic_test (tests, ntests, sizeof(TESTSeqOfSeq2),
175 (generic_encode)encode_TESTSeqOfSeq2,
176 (generic_length)length_TESTSeqOfSeq2,
177 (generic_decode)decode_TESTSeqOfSeq2,
178 (generic_free)free_TESTSeqOfSeq2,
179 cmp_dummy,
180 NULL);
181 return ret;
182 }
183
184 static int
185 test_seqof2(void)
186 {
187 struct test_case tests[] = {
188 { NULL, 4,
189 "\x30\x02\x30\x00",
190 "seqof2 1" },
191 { NULL, 9,
192 "\x30\x07\x30\x05\x1b\x03\x66\x6f\x6f",
193 "seqof2 2" },
194 { NULL, 14,
195 "\x30\x0c\x30\x0a\x1b\x03\x66\x6f\x6f\x1b\x03\x62\x61\x72",
196 "seqof2 3" }
197 };
198
199 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
200 TESTSeqOf2 c0, c1, c2;
201 heim_general_string i[2];
202
203 i[0] = "foo";
204 i[1] = "bar";
205
206 c0.strings.val = NULL;
207 c0.strings.len = 0;
208 tests[0].val = &c0;
209
210 c1.strings.len = 1;
211 c1.strings.val = i;
212 tests[1].val = &c1;
213
214 c2.strings.len = 2;
215 c2.strings.val = i;
216 tests[2].val = &c2;
217
218 ret += generic_test (tests, ntests, sizeof(TESTSeqOf2),
219 (generic_encode)encode_TESTSeqOf2,
220 (generic_length)length_TESTSeqOf2,
221 (generic_decode)decode_TESTSeqOf2,
222 (generic_free)free_TESTSeqOf2,
223 cmp_dummy,
224 NULL);
225 return ret;
226 }
227
228 static int
229 test_seqof3(void)
230 {
231 struct test_case tests[] = {
232 { NULL, 2,
233 "\x30\x00",
234 "seqof3 0" },
235 { NULL, 4,
236 "\x30\x02\x30\x00",
237 "seqof3 1" },
238 { NULL, 9,
239 "\x30\x07\x30\x05\x1b\x03\x66\x6f\x6f",
240 "seqof3 2" },
241 { NULL, 14,
242 "\x30\x0c\x30\x0a\x1b\x03\x66\x6f\x6f\x1b\x03\x62\x61\x72",
243 "seqof3 3" }
244 };
245
246 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
247 TESTSeqOf3 c0, c1, c2, c3;
248 struct TESTSeqOf3_strings s1, s2, s3;
249 heim_general_string i[2];
250
251 i[0] = "foo";
252 i[1] = "bar";
253
254 c0.strings = NULL;
255 tests[0].val = &c0;
256
257 s1.val = NULL;
258 s1.len = 0;
259 c1.strings = &s1;
260 tests[1].val = &c1;
261
262 s2.len = 1;
263 s2.val = i;
264 c2.strings = &s2;
265 tests[2].val = &c2;
266
267 s3.len = 2;
268 s3.val = i;
269 c3.strings = &s3;
270 tests[3].val = &c3;
271
272 ret += generic_test (tests, ntests, sizeof(TESTSeqOf3),
273 (generic_encode)encode_TESTSeqOf3,
274 (generic_length)length_TESTSeqOf3,
275 (generic_decode)decode_TESTSeqOf3,
276 (generic_free)free_TESTSeqOf3,
277 cmp_dummy,
278 NULL);
279 return ret;
280 }
281
282
283 static int
284 test_seqof4(void)
285 {
286 struct test_case tests[] = {
287 { NULL, 2,
288 "\x30\x00",
289 "seq4 0" },
290 { NULL, 4,
291 "\x30\x02" "\xa1\x00",
292 "seq4 1" },
293 { NULL, 8,
294 "\x30\x06" "\xa0\x02\x30\x00" "\xa1\x00",
295 "seq4 2" },
296 { NULL, 2 + (2 + 0x18) + (2 + 0x27) + (2 + 0x31),
297 "\x30\x76" /* 2 SEQ */
298 "\xa0\x18\x30\x16" /* 4 [0] SEQ */
299 "\x30\x14" /* 2 SEQ */
300 "\x04\x00" /* 2 OCTET-STRING */
301 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
302 "\x02\x01\x01" /* 3 INT */
303 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
304 /* 11 INT */
305 "\xa1\x27" /* 2 [1] IMPL SEQ */
306 "\x30\x25" /* 2 SEQ */
307 "\x02\x01\x01" /* 3 INT */
308 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
309 /* 11 INT */
310 "\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
311 /* 11 INT */
312 "\x04\x00" /* 2 OCTET-STRING */
313 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
314 "\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
315 "\xa2\x31" /* 2 [2] IMPL SEQ */
316 "\x30\x2f" /* 2 SEQ */
317 "\x04\x00" /* 2 OCTET-STRING */
318 "\x02\x01\x01" /* 3 INT */
319 "\x04\x02\x01\x02" /* 4 OCTET-STRING */
320 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
321 /* 11 INT */
322 "\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
323 "\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
324 /* 11 INT */
325 "\x04\x01\x00" /* 3 OCTET-STRING */
326 "\x02\x05\x01\x00\x00\x00\x00", /* 7 INT */
327 "seq4 3" },
328 };
329
330 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
331 TESTSeqOf4 c[4];
332 struct TESTSeqOf4_b1 b1[4];
333 struct TESTSeqOf4_b2 b2[4];
334 struct TESTSeqOf4_b3 b3[4];
335 struct TESTSeqOf4_b1_val b1val[4];
336 struct TESTSeqOf4_b2_val b2val[4];
337 struct TESTSeqOf4_b3_val b3val[4];
338
339 c[0].b1 = NULL;
340 c[0].b2 = NULL;
341 c[0].b3 = NULL;
342 tests[0].val = &c[0];
343
344 b2[1].len = 0;
345 b2[1].val = NULL;
346 c[1].b1 = NULL;
347 c[1].b2 = &b2[1];
348 c[1].b3 = NULL;
349 tests[1].val = &c[1];
350
351 b1[2].len = 0;
352 b1[2].val = NULL;
353 b2[2].len = 0;
354 b2[2].val = NULL;
355 c[2].b1 = &b1[2];
356 c[2].b2 = &b2[2];
357 c[2].b3 = NULL;
358 tests[2].val = &c[2];
359
360 b1val[3].s1.data = "";
361 b1val[3].s1.length = 0;
362 b1val[3].u1 = 1LL;
363 b1val[3].s2.data = "\x01\x02";
364 b1val[3].s2.length = 2;
365 b1val[3].u2 = (TESTuint64)-1LL;
366
367 b2val[3].s1.data = "";
368 b2val[3].s1.length = 0;
369 b2val[3].u1 = 1LL;
370 b2val[3].s2.data = "\x01\x02";
371 b2val[3].s2.length = 2;
372 b2val[3].u2 = (TESTuint64)-1LL;
373 b2val[3].s3.data = "\x00\x01\x02\x03";
374 b2val[3].s3.length = 4;
375 b2val[3].u3 = 1ULL<<63;
376
377 b3val[3].s1.data = "";
378 b3val[3].s1.length = 0;
379 b3val[3].u1 = 1LL;
380 b3val[3].s2.data = "\x01\x02";
381 b3val[3].s2.length = 2;
382 b3val[3].u2 = (TESTuint64)-1LL;
383 b3val[3].s3.data = "\x00\x01\x02\x03";
384 b3val[3].s3.length = 4;
385 b3val[3].u3 = 1ULL<<63;
386 b3val[3].s4.data = "\x00";
387 b3val[3].s4.length = 1;
388 b3val[3].u4 = 1LL<<32;
389
390 b1[3].len = 1;
391 b1[3].val = &b1val[3];
392 b2[3].len = 1;
393 b2[3].val = &b2val[3];
394 b3[3].len = 1;
395 b3[3].val = &b3val[3];
396 c[3].b1 = &b1[3];
397 c[3].b2 = &b2[3];
398 c[3].b3 = &b3[3];
399 tests[3].val = &c[3];
400
401 ret += generic_test (tests, ntests, sizeof(TESTSeqOf4),
402 (generic_encode)encode_TESTSeqOf4,
403 (generic_length)length_TESTSeqOf4,
404 (generic_decode)decode_TESTSeqOf4,
405 (generic_free)free_TESTSeqOf4,
406 cmp_dummy,
407 NULL);
408 return ret;
409 }
410
411 static int
412 cmp_test_seqof5 (void *a, void *b)
413 {
414 TESTSeqOf5 *aval = a;
415 TESTSeqOf5 *bval = b;
416
417 IF_OPT_COMPARE(aval, bval, outer) {
418 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u0);
419 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s0);
420 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u1);
421 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s1);
422 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u2);
423 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s2);
424 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u3);
425 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s3);
426 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u4);
427 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s4);
428 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u5);
429 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s5);
430 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u6);
431 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s6);
432 COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u7);
433 COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s7);
434 }
435 return 0;
436 }
437
438 static int
439 test_seqof5(void)
440 {
441 struct test_case tests[] = {
442 { NULL, 2, "\x30\x00", "seq5 0" },
443 { NULL, 126,
444 "\x30\x7c" /* SEQ */
445 "\x30\x7a" /* SEQ */
446 "\x30\x78" /* SEQ */
447 "\x02\x01\x01" /* INT 1 */
448 "\x04\x06\x01\x01\x01\x01\x01\x01" /* "\0x1"x6 */
449 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfe" /* INT ~1 */
450 "\x04\x06\x02\x02\x02\x02\x02\x02" /* "\x02"x6 */
451 "\x02\x01\x02" /* INT 2 */
452 "\x04\x06\x03\x03\x03\x03\x03\x03" /* "\x03"x6 */
453 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfd" /* INT ~2 */
454 "\x04\x06\x04\x04\x04\x04\x04\x04" /* ... */
455 "\x02\x01\x03"
456 "\x04\x06\x05\x05\x05\x05\x05\x05"
457 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfc"
458 "\x04\x06\x06\x06\x06\x06\x06\x06"
459 "\x02\x01\x04"
460 "\x04\x06\x07\x07\x07\x07\x07\x07"
461 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfb"
462 "\x04\x06\x08\x08\x08\x08\x08\x08",
463 "seq5 1" },
464 };
465
466 int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
467 TESTSeqOf5 c[2];
468 struct TESTSeqOf5_outer outer;
469 struct TESTSeqOf5_outer_inner inner;
470 TESTuint64 u[8];
471 heim_octet_string s[8];
472 int i;
473
474 c[0].outer = NULL;
475 tests[0].val = &c[0];
476
477 for (i = 0; i < 8; ++i) {
478 u[i] = (i&1) == 0 ? i/2+1 : ~(i/2+1);
479 s[i].data = memset(malloc(s[i].length = 6), i+1, 6);
480 }
481
482 inner.u0 = u[0]; inner.u1 = u[1]; inner.u2 = u[2]; inner.u3 = u[3];
483 inner.u4 = u[4]; inner.u5 = u[5]; inner.u6 = u[6]; inner.u7 = u[7];
484 inner.s0 = s[0]; inner.s1 = s[1]; inner.s2 = s[2]; inner.s3 = s[3];
485 inner.s4 = s[4]; inner.s5 = s[5]; inner.s6 = s[6]; inner.s7 = s[7];
486
487 outer.inner = inner;
488 c[1].outer = &outer;
489 tests[1].val = &c[1];
490
491 ret += generic_test (tests, ntests, sizeof(TESTSeqOf5),
492 (generic_encode)encode_TESTSeqOf5,
493 (generic_length)length_TESTSeqOf5,
494 (generic_decode)decode_TESTSeqOf5,
495 (generic_free)free_TESTSeqOf5,
496 cmp_test_seqof5,
497 NULL);
498
499 for (i = 0; i < 8; ++i)
500 free(s[i].data);
501
502 return ret;
503 }
504
505 int
506 main(int argc, char **argv)
507 {
508 int ret = 0;
509
510 ret += test_uint64();
511 ret += test_seqofseq();
512 ret += test_seqofseq2();
513 ret += test_seqof2();
514 ret += test_seqof3();
515 ret += test_seqof4();
516 ret += test_seqof5();
517
518 return ret;
519 }
Heimdal