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