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