crypto/heimdal/lib/asn1/check-gen.c

   1 /*
   2  * Copyright (c) 1999 - 2005 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  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
  50 #include "check-common.h"
  51
  52 RCSID("$Id: check-gen.c 21539 2007-07-14 16:12:04Z lha $");
  53
  54 static char *lha_principal[] = { "lha" };
  55 static char *lharoot_princ[] = { "lha", "root" };
  56 static char *datan_princ[] = { "host", "nutcracker.e.kth.se" };
  57 static char *nada_tgt_principal[] = { "krbtgt", "NADA.KTH.SE" };
  58
  59
  60 #define IF_OPT_COMPARE(ac,bc,e) \
  61         if (((ac)->e == NULL && (bc)->e != NULL) || (((ac)->e != NULL && (bc)->e == NULL))) return 1; if ((ab)->e)
  62 #define COMPARE_OPT_STRING(ac,bc,e) \
  63         do { if (strcmp(*(ac)->e, *(bc)->e) != 0) return 1; } while(0)
  64 #define COMPARE_OPT_OCTECT_STRING(ac,bc,e) \
  65         do { if ((ac)->e->length != (bc)->e->length || memcmp((ac)->e->data, (bc)->e->data, (ac)->e->length) != 0) return 1; } while(0)
  66 #define COMPARE_STRING(ac,bc,e) \
  67         do { if (strcmp((ac)->e, (bc)->e) != 0) return 1; } while(0)
  68 #define COMPARE_INTEGER(ac,bc,e) \
  69         do { if ((ac)->e != (bc)->e) return 1; } while(0)
  70 #define COMPARE_MEM(ac,bc,e,len) \
  71         do { if (memcmp((ac)->e, (bc)->e,len) != 0) return 1; } while(0)
  72
  73 static int
  74 cmp_principal (void *a, void *b)
  75 {
  76     Principal *pa = a;
  77     Principal *pb = b;
  78     int i;
  79
  80     COMPARE_STRING(pa,pb,realm);
  81     COMPARE_INTEGER(pa,pb,name.name_type);
  82     COMPARE_INTEGER(pa,pb,name.name_string.len);
  83
  84     for (i = 0; i < pa->name.name_string.len; i++)
  85         COMPARE_STRING(pa,pb,name.name_string.val[i]);
  86
  87     return 0;
  88 }
  89
  90 static int
  91 test_principal (void)
  92 {
  93
  94     struct test_case tests[] = {
  95         { NULL, 29,
  96           "\x30\x1b\xa0\x10\x30\x0e\xa0\x03\x02\x01\x01\xa1\x07\x30\x05\x1b"
  97           "\x03\x6c\x68\x61\xa1\x07\x1b\x05\x53\x55\x2e\x53\x45"
  98         },
  99         { NULL, 35,
 100           "\x30\x21\xa0\x16\x30\x14\xa0\x03\x02\x01\x01\xa1\x0d\x30\x0b\x1b"
 101           "\x03\x6c\x68\x61\x1b\x04\x72\x6f\x6f\x74\xa1\x07\x1b\x05\x53\x55"
 102           "\x2e\x53\x45"
 103         },
 104         { NULL, 54,
 105           "\x30\x34\xa0\x26\x30\x24\xa0\x03\x02\x01\x03\xa1\x1d\x30\x1b\x1b"
 106           "\x04\x68\x6f\x73\x74\x1b\x13\x6e\x75\x74\x63\x72\x61\x63\x6b\x65"
 107           "\x72\x2e\x65\x2e\x6b\x74\x68\x2e\x73\x65\xa1\x0a\x1b\x08\x45\x2e"
 108           "\x4b\x54\x48\x2e\x53\x45"
 109         }
 110     };
 111
 112
 113     Principal values[] = {
 114         { { KRB5_NT_PRINCIPAL, { 1, lha_principal } },  "SU.SE" },
 115         { { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } },  "SU.SE" },
 116         { { KRB5_NT_SRV_HST, { 2, datan_princ } },  "E.KTH.SE" }
 117     };
 118     int i, ret;
 119     int ntests = sizeof(tests) / sizeof(*tests);
 120
 121     for (i = 0; i < ntests; ++i) {
 122         tests[i].val = &values[i];
 123         asprintf (&tests[i].name, "Principal %d", i);
 124     }
 125
 126     ret = generic_test (tests, ntests, sizeof(Principal),
 127                         (generic_encode)encode_Principal,
 128                         (generic_length)length_Principal,
 129                         (generic_decode)decode_Principal,
 130                         (generic_free)free_Principal,
 131                         cmp_principal);
 132     for (i = 0; i < ntests; ++i)
 133         free (tests[i].name);
 134
 135     return ret;
 136 }
 137
 138 static int
 139 cmp_authenticator (void *a, void *b)
 140 {
 141     Authenticator *aa = a;
 142     Authenticator *ab = b;
 143     int i;
 144
 145     COMPARE_INTEGER(aa,ab,authenticator_vno);
 146     COMPARE_STRING(aa,ab,crealm);
 147
 148     COMPARE_INTEGER(aa,ab,cname.name_type);
 149     COMPARE_INTEGER(aa,ab,cname.name_string.len);
 150
 151     for (i = 0; i < aa->cname.name_string.len; i++)
 152         COMPARE_STRING(aa,ab,cname.name_string.val[i]);
 153
 154     return 0;
 155 }
 156
 157 static int
 158 test_authenticator (void)
 159 {
 160     struct test_case tests[] = {
 161         { NULL, 63,
 162           "\x62\x3d\x30\x3b\xa0\x03\x02\x01\x05\xa1\x0a\x1b\x08"
 163           "\x45\x2e\x4b\x54\x48\x2e\x53\x45\xa2\x10\x30\x0e\xa0"
 164           "\x03\x02\x01\x01\xa1\x07\x30\x05\x1b\x03\x6c\x68\x61"
 165           "\xa4\x03\x02\x01\x0a\xa5\x11\x18\x0f\x31\x39\x37\x30"
 166           "\x30\x31\x30\x31\x30\x30\x30\x31\x33\x39\x5a"
 167         },
 168         { NULL, 67,
 169           "\x62\x41\x30\x3f\xa0\x03\x02\x01\x05\xa1\x07\x1b\x05"
 170           "\x53\x55\x2e\x53\x45\xa2\x16\x30\x14\xa0\x03\x02\x01"
 171           "\x01\xa1\x0d\x30\x0b\x1b\x03\x6c\x68\x61\x1b\x04\x72"
 172           "\x6f\x6f\x74\xa4\x04\x02\x02\x01\x24\xa5\x11\x18\x0f"
 173           "\x31\x39\x37\x30\x30\x31\x30\x31\x30\x30\x31\x36\x33"
 174           "\x39\x5a"
 175         }
 176     };
 177
 178     Authenticator values[] = {
 179         { 5, "E.KTH.SE", { KRB5_NT_PRINCIPAL, { 1, lha_principal } },
 180           NULL, 10, 99, NULL, NULL, NULL },
 181         { 5, "SU.SE", { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } },
 182           NULL, 292, 999, NULL, NULL, NULL }
 183     };
 184     int i, ret;
 185     int ntests = sizeof(tests) / sizeof(*tests);
 186
 187     for (i = 0; i < ntests; ++i) {
 188         tests[i].val = &values[i];
 189         asprintf (&tests[i].name, "Authenticator %d", i);
 190     }
 191
 192     ret = generic_test (tests, ntests, sizeof(Authenticator),
 193                         (generic_encode)encode_Authenticator,
 194                         (generic_length)length_Authenticator,
 195                         (generic_decode)decode_Authenticator,
 196                         (generic_free)free_Authenticator,
 197                         cmp_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_OCTECT_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 }
 293
 294 static int
 295 cmp_Name (void *a, void *b)
 296 {
 297     Name *aa = a;
 298     Name *ab = b;
 299
 300     COMPARE_INTEGER(aa,ab,element);
 301
 302     return 0;
 303 }
 304
 305 static int
 306 test_Name (void)
 307 {
 308     struct test_case tests[] = {
 309         { NULL, 35,
 310           "\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
 311           "\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
 312           "\x4f\x4c\x4d",
 313           "Name CN=Love+L=STOCKHOLM"
 314         },
 315         { NULL, 35,
 316           "\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
 317           "\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
 318           "\x4f\x4c\x4d",
 319           "Name L=STOCKHOLM+CN=Love"
 320         }
 321     };
 322
 323     int ntests = sizeof(tests) / sizeof(*tests);
 324     Name n1, n2;
 325     RelativeDistinguishedName rdn1[1];
 326     RelativeDistinguishedName rdn2[1];
 327     AttributeTypeAndValue atv1[2];
 328     AttributeTypeAndValue atv2[2];
 329     unsigned cmp_CN[] = { 2, 5, 4, 3 };
 330     unsigned cmp_L[] = { 2, 5, 4, 7 };
 331
 332     /* n1 */
 333     n1.element = choice_Name_rdnSequence;
 334     n1.u.rdnSequence.val = rdn1;
 335     n1.u.rdnSequence.len = sizeof(rdn1)/sizeof(rdn1[0]);
 336     rdn1[0].val = atv1;
 337     rdn1[0].len = sizeof(atv1)/sizeof(atv1[0]);
 338
 339     atv1[0].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
 340     atv1[0].type.components = cmp_CN;
 341     atv1[0].value.element = choice_DirectoryString_printableString;
 342     atv1[0].value.u.printableString = "Love";
 343
 344     atv1[1].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
 345     atv1[1].type.components = cmp_L;
 346     atv1[1].value.element = choice_DirectoryString_printableString;
 347     atv1[1].value.u.printableString = "STOCKHOLM";
 348
 349     /* n2 */
 350     n2.element = choice_Name_rdnSequence;
 351     n2.u.rdnSequence.val = rdn2;
 352     n2.u.rdnSequence.len = sizeof(rdn2)/sizeof(rdn2[0]);
 353     rdn2[0].val = atv2;
 354     rdn2[0].len = sizeof(atv2)/sizeof(atv2[0]);
 355
 356     atv2[0].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
 357     atv2[0].type.components = cmp_L;
 358     atv2[0].value.element = choice_DirectoryString_printableString;
 359     atv2[0].value.u.printableString = "STOCKHOLM";
 360
 361     atv2[1].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
 362     atv2[1].type.components = cmp_CN;
 363     atv2[1].value.element = choice_DirectoryString_printableString;
 364     atv2[1].value.u.printableString = "Love";
 365
 366     /* */
 367     tests[0].val = &n1;
 368     tests[1].val = &n2;
 369
 370     return generic_test (tests, ntests, sizeof(Name),
 371                          (generic_encode)encode_Name,
 372                          (generic_length)length_Name,
 373                          (generic_decode)decode_Name,
 374                          (generic_free)free_Name,
 375                          cmp_Name);
 376 }
 377
 378 static int
 379 cmp_KeyUsage (void *a, void *b)
 380 {
 381     KeyUsage *aa = a;
 382     KeyUsage *ab = b;
 383
 384     return KeyUsage2int(*aa) != KeyUsage2int(*ab);
 385 }
 386
 387 static int
 388 test_bit_string (void)
 389 {
 390     struct test_case tests[] = {
 391         { NULL, 4,
 392           "\x03\x02\x07\x80",
 393           "bitstring 1"
 394         },
 395         { NULL, 4,
 396           "\x03\x02\x05\xa0",
 397           "bitstring 2"
 398         },
 399         { NULL, 5,
 400           "\x03\x03\x07\x00\x80",
 401           "bitstring 3"
 402         },
 403         { NULL, 3,
 404           "\x03\x01\x00",
 405           "bitstring 4"
 406         }
 407     };
 408
 409     int ntests = sizeof(tests) / sizeof(*tests);
 410     KeyUsage ku1, ku2, ku3, ku4;
 411
 412     memset(&ku1, 0, sizeof(ku1));
 413     ku1.digitalSignature = 1;
 414     tests[0].val = &ku1;
 415
 416     memset(&ku2, 0, sizeof(ku2));
 417     ku2.digitalSignature = 1;
 418     ku2.keyEncipherment = 1;
 419     tests[1].val = &ku2;
 420
 421     memset(&ku3, 0, sizeof(ku3));
 422     ku3.decipherOnly = 1;
 423     tests[2].val = &ku3;
 424
 425     memset(&ku4, 0, sizeof(ku4));
 426     tests[3].val = &ku4;
 427
 428
 429     return generic_test (tests, ntests, sizeof(KeyUsage),
 430                          (generic_encode)encode_KeyUsage,
 431                          (generic_length)length_KeyUsage,
 432                          (generic_decode)decode_KeyUsage,
 433                          (generic_free)free_KeyUsage,
 434                          cmp_KeyUsage);
 435 }
 436
 437 static int
 438 cmp_TESTLargeTag (void *a, void *b)
 439 {
 440     TESTLargeTag *aa = a;
 441     TESTLargeTag *ab = b;
 442
 443     COMPARE_INTEGER(aa,ab,foo);
 444     return 0;
 445 }
 446
 447 static int
 448 test_large_tag (void)
 449 {
 450     struct test_case tests[] = {
 451         { NULL,  8,  "\x30\x06\xbf\x7f\x03\x02\x01\x01", "large tag 1" }
 452     };
 453
 454     int ntests = sizeof(tests) / sizeof(*tests);
 455     TESTLargeTag lt1;
 456
 457     memset(&lt1, 0, sizeof(lt1));
 458     lt1.foo = 1;
 459
 460     tests[0].val = &lt1;
 461
 462     return generic_test (tests, ntests, sizeof(TESTLargeTag),
 463                          (generic_encode)encode_TESTLargeTag,
 464                          (generic_length)length_TESTLargeTag,
 465                          (generic_decode)decode_TESTLargeTag,
 466                          (generic_free)free_TESTLargeTag,
 467                          cmp_TESTLargeTag);
 468 }
 469
 470 struct test_data {
 471     int ok;
 472     size_t len;
 473     size_t expected_len;
 474     void *data;
 475 };
 476
 477 static int
 478 check_tag_length(void)
 479 {
 480     struct test_data td[] = {
 481         { 1, 3, 3, "\x02\x01\x00"},
 482         { 1, 3, 3, "\x02\x01\x7f"},
 483         { 1, 4, 4, "\x02\x02\x00\x80"},
 484         { 1, 4, 4, "\x02\x02\x01\x00"},
 485         { 1, 4, 4, "\x02\x02\x02\x00"},
 486         { 0, 3, 0, "\x02\x02\x00"},
 487         { 0, 3, 0, "\x02\x7f\x7f"},
 488         { 0, 4, 0, "\x02\x03\x00\x80"},
 489         { 0, 4, 0, "\x02\x7f\x01\x00"},
 490         { 0, 5, 0, "\x02\xff\x7f\x02\x00"}
 491     };
 492     size_t sz;
 493     krb5uint32 values[] = {0, 127, 128, 256, 512,
 494                          0, 127, 128, 256, 512 };
 495     krb5uint32 u;
 496     int i, ret, failed = 0;
 497     void *buf;
 498
 499     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
 500         struct map_page *page;
 501
 502         buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
 503
 504         ret = decode_krb5uint32(buf, td[i].len, &u, &sz);
 505         if (ret) {
 506             if (td[i].ok) {
 507                 printf("failed with tag len test %d\n", i);
 508                 failed = 1;
 509             }
 510         } else {
 511             if (td[i].ok == 0) {
 512                 printf("failed with success for tag len test %d\n", i);
 513                 failed = 1;
 514             }
 515             if (td[i].expected_len != sz) {
 516                 printf("wrong expected size for tag test %d\n", i);
 517                 failed = 1;
 518             }
 519             if (values[i] != u) {
 520                 printf("wrong value for tag test %d\n", i);
 521                 failed = 1;
 522             }
 523         }
 524         map_free(page, "test", "decode");
 525     }
 526     return failed;
 527 }
 528
 529 static int
 530 cmp_TESTChoice (void *a, void *b)
 531 {
 532     return 0;
 533 }
 534
 535 static int
 536 test_choice (void)
 537 {
 538     struct test_case tests[] = {
 539         { NULL,  5,  "\xa1\x03\x02\x01\x01", "large choice 1" },
 540         { NULL,  5,  "\xa2\x03\x02\x01\x02", "large choice 2" }
 541     };
 542
 543     int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
 544     TESTChoice1 c1;
 545     TESTChoice1 c2_1;
 546     TESTChoice2 c2_2;
 547
 548     memset(&c1, 0, sizeof(c1));
 549     c1.element = choice_TESTChoice1_i1;
 550     c1.u.i1 = 1;
 551     tests[0].val = &c1;
 552
 553     memset(&c2_1, 0, sizeof(c2_1));
 554     c2_1.element = choice_TESTChoice1_i2;
 555     c2_1.u.i2 = 2;
 556     tests[1].val = &c2_1;
 557
 558     ret += generic_test (tests, ntests, sizeof(TESTChoice1),
 559                          (generic_encode)encode_TESTChoice1,
 560                          (generic_length)length_TESTChoice1,
 561                          (generic_decode)decode_TESTChoice1,
 562                          (generic_free)free_TESTChoice1,
 563                          cmp_TESTChoice);
 564
 565     memset(&c2_2, 0, sizeof(c2_2));
 566     c2_2.element = choice_TESTChoice2_asn1_ellipsis;
 567     c2_2.u.asn1_ellipsis.data = "\xa2\x03\x02\x01\x02";
 568     c2_2.u.asn1_ellipsis.length = 5;
 569     tests[1].val = &c2_2;
 570
 571     ret += generic_test (tests, ntests, sizeof(TESTChoice2),
 572                          (generic_encode)encode_TESTChoice2,
 573                          (generic_length)length_TESTChoice2,
 574                          (generic_decode)decode_TESTChoice2,
 575                          (generic_free)free_TESTChoice2,
 576                          cmp_TESTChoice);
 577
 578     return ret;
 579 }
 580
 581 static int
 582 cmp_TESTImplicit (void *a, void *b)
 583 {
 584     TESTImplicit *aa = a;
 585     TESTImplicit *ab = b;
 586
 587     COMPARE_INTEGER(aa,ab,ti1);
 588     COMPARE_INTEGER(aa,ab,ti2.foo);
 589     COMPARE_INTEGER(aa,ab,ti3);
 590     return 0;
 591 }
 592
 593 /*
 594 UNIV CONS Sequence 14
 595   CONTEXT PRIM 0 1 00
 596   CONTEXT CONS 1 6
 597    CONTEXT CONS 127 3
 598      UNIV PRIM Integer 1 02
 599   CONTEXT PRIM 2 1 03
 600 */
 601
 602 static int
 603 test_implicit (void)
 604 {
 605     struct test_case tests[] = {
 606         { NULL,  16,
 607           "\x30\x0e\x80\x01\x00\xa1\x06\xbf"
 608           "\x7f\x03\x02\x01\x02\x82\x01\x03",
 609           "implicit 1" }
 610     };
 611
 612     int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
 613     TESTImplicit c0;
 614
 615     memset(&c0, 0, sizeof(c0));
 616     c0.ti1 = 0;
 617     c0.ti2.foo = 2;
 618     c0.ti3 = 3;
 619     tests[0].val = &c0;
 620
 621     ret += generic_test (tests, ntests, sizeof(TESTImplicit),
 622                          (generic_encode)encode_TESTImplicit,
 623                          (generic_length)length_TESTImplicit,
 624                          (generic_decode)decode_TESTImplicit,
 625                          (generic_free)free_TESTImplicit,
 626                          cmp_TESTImplicit);
 627
 628 #ifdef IMPLICIT_TAGGING_WORKS
 629     ret += generic_test (tests, ntests, sizeof(TESTImplicit2),
 630                          (generic_encode)encode_TESTImplicit2,
 631                          (generic_length)length_TESTImplicit2,
 632                          (generic_decode)decode_TESTImplicit2,
 633                          (generic_free)free_TESTImplicit2,
 634                          cmp_TESTImplicit);
 635
 636 #endif /* IMPLICIT_TAGGING_WORKS */
 637     return ret;
 638 }
 639
 640 static int
 641 cmp_TESTAlloc (void *a, void *b)
 642 {
 643     TESTAlloc *aa = a;
 644     TESTAlloc *ab = b;
 645
 646     IF_OPT_COMPARE(aa,ab,tagless) {
 647         COMPARE_INTEGER(aa,ab,tagless->ai);
 648     }
 649
 650     COMPARE_INTEGER(aa,ab,three);
 651
 652     IF_OPT_COMPARE(aa,ab,tagless2) {
 653         COMPARE_OPT_OCTECT_STRING(aa, ab, tagless2);
 654     }
 655
 656     return 0;
 657 }
 658
 659 /*
 660 UNIV CONS Sequence 12
 661   UNIV CONS Sequence 5
 662     CONTEXT CONS 0 3
 663       UNIV PRIM Integer 1 01
 664   CONTEXT CONS 1 3
 665     UNIV PRIM Integer 1 03
 666
 667 UNIV CONS Sequence 5
 668   CONTEXT CONS 1 3
 669     UNIV PRIM Integer 1 03
 670
 671 UNIV CONS Sequence 8
 672   CONTEXT CONS 1 3
 673     UNIV PRIM Integer 1 04
 674   UNIV PRIM Integer 1 05
 675
 676 */
 677
 678 static int
 679 test_taglessalloc (void)
 680 {
 681     struct test_case tests[] = {
 682         { NULL,  14,
 683           "\x30\x0c\x30\x05\xa0\x03\x02\x01\x01\xa1\x03\x02\x01\x03",
 684           "alloc 1" },
 685         { NULL,  7,
 686           "\x30\x05\xa1\x03\x02\x01\x03",
 687           "alloc 2" },
 688         { NULL,  10,
 689           "\x30\x08\xa1\x03\x02\x01\x04\x02\x01\x05",
 690           "alloc 3" }
 691     };
 692
 693     int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
 694     TESTAlloc c1, c2, c3;
 695     heim_any any3;
 696
 697     memset(&c1, 0, sizeof(c1));
 698     c1.tagless = ecalloc(1, sizeof(*c1.tagless));
 699     c1.tagless->ai = 1;
 700     c1.three = 3;
 701     tests[0].val = &c1;
 702
 703     memset(&c2, 0, sizeof(c2));
 704     c2.tagless = NULL;
 705     c2.three = 3;
 706     tests[1].val = &c2;
 707
 708     memset(&c3, 0, sizeof(c3));
 709     c3.tagless = NULL;
 710     c3.three = 4;
 711     c3.tagless2 = &any3;
 712     any3.data = "\x02\x01\x05";
 713     any3.length = 3;
 714     tests[2].val = &c3;
 715
 716     ret += generic_test (tests, ntests, sizeof(TESTAlloc),
 717                          (generic_encode)encode_TESTAlloc,
 718                          (generic_length)length_TESTAlloc,
 719                          (generic_decode)decode_TESTAlloc,
 720                          (generic_free)free_TESTAlloc,
 721                          cmp_TESTAlloc);
 722
 723     free(c1.tagless);
 724
 725     return ret;
 726 }
 727
 728
 729 static int
 730 check_fail_largetag(void)
 731 {
 732     struct test_case tests[] = {
 733         {NULL, 14, "\x30\x0c\xbf\x87\xff\xff\xff\xff\xff\x7f\x03\x02\x01\x01",
 734          "tag overflow"},
 735         {NULL, 0, "", "empty buffer"},
 736         {NULL, 7, "\x30\x05\xa1\x03\x02\x02\x01",
 737          "one too short" },
 738         {NULL, 7, "\x30\x04\xa1\x03\x02\x02\x01"
 739          "two too short" },
 740         {NULL, 7, "\x30\x03\xa1\x03\x02\x02\x01",
 741          "three too short" },
 742         {NULL, 7, "\x30\x02\xa1\x03\x02\x02\x01",
 743          "four too short" },
 744         {NULL, 7, "\x30\x01\xa1\x03\x02\x02\x01",
 745          "five too short" },
 746         {NULL, 7, "\x30\x00\xa1\x03\x02\x02\x01",
 747          "six too short" },
 748         {NULL, 7, "\x30\x05\xa1\x04\x02\x02\x01",
 749          "inner one too long" },
 750         {NULL, 7, "\x30\x00\xa1\x02\x02\x02\x01",
 751          "inner one too short" },
 752         {NULL, 8, "\x30\x05\xbf\x7f\x03\x02\x02\x01",
 753          "inner one too short"},
 754         {NULL, 8, "\x30\x06\xbf\x64\x03\x02\x01\x01",
 755          "wrong tag"},
 756         {NULL, 10, "\x30\x08\xbf\x9a\x9b\x38\x03\x02\x01\x01",
 757          "still wrong tag"}
 758     };
 759     int ntests = sizeof(tests) / sizeof(*tests);
 760
 761     return generic_decode_fail(tests, ntests, sizeof(TESTLargeTag),
 762                                (generic_decode)decode_TESTLargeTag);
 763 }
 764
 765
 766 static int
 767 check_fail_sequence(void)
 768 {
 769     struct test_case tests[] = {
 770         {NULL, 0, "", "empty buffer"},
 771         {NULL, 24,
 772          "\x30\x16\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
 773          "\x02\x01\x01\xa2\x03\x02\x01\x01"
 774          "missing one byte from the end, internal length ok"},
 775         {NULL, 25,
 776          "\x30\x18\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
 777          "\x02\x01\x01\xa2\x03\x02\x01\x01",
 778          "inner length one byte too long"},
 779         {NULL, 24,
 780          "\x30\x17\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01"
 781          "\x01\x02\x01\x01\xa2\x03\x02\x01\x01",
 782          "correct buffer but missing one too short"}
 783     };
 784     int ntests = sizeof(tests) / sizeof(*tests);
 785
 786     return generic_decode_fail(tests, ntests, sizeof(TESTSeq),
 787                                (generic_decode)decode_TESTSeq);
 788 }
 789
 790 static int
 791 check_fail_choice(void)
 792 {
 793     struct test_case tests[] = {
 794         {NULL, 6,
 795          "\xa1\x02\x02\x01\x01",
 796          "one too short"},
 797         {NULL, 6,
 798          "\xa1\x03\x02\x02\x01",
 799          "one too short inner"}
 800     };
 801     int ntests = sizeof(tests) / sizeof(*tests);
 802
 803     return generic_decode_fail(tests, ntests, sizeof(TESTChoice1),
 804                                (generic_decode)decode_TESTChoice1);
 805 }
 806
 807 static int
 808 check_seq(void)
 809 {
 810     TESTSeqOf seq;
 811     TESTInteger i;
 812     int ret;
 813
 814     seq.val = NULL;
 815     seq.len = 0;
 816
 817     ret = add_TESTSeqOf(&seq, &i);
 818     if (ret) { printf("failed adding\n"); goto out; }
 819     ret = add_TESTSeqOf(&seq, &i);
 820     if (ret) { printf("failed adding\n"); goto out; }
 821     ret = add_TESTSeqOf(&seq, &i);
 822     if (ret) { printf("failed adding\n"); goto out; }
 823     ret = add_TESTSeqOf(&seq, &i);
 824     if (ret) { printf("failed adding\n"); goto out; }
 825
 826     ret = remove_TESTSeqOf(&seq, seq.len - 1);
 827     if (ret) { printf("failed removing\n"); goto out; }
 828     ret = remove_TESTSeqOf(&seq, 2);
 829     if (ret) { printf("failed removing\n"); goto out; }
 830     ret = remove_TESTSeqOf(&seq, 0);
 831     if (ret) { printf("failed removing\n"); goto out; }
 832     ret = remove_TESTSeqOf(&seq, 0);
 833     if (ret) { printf("failed removing\n"); goto out; }
 834     ret = remove_TESTSeqOf(&seq, 0);
 835     if (ret == 0) {
 836         printf("can remove from empty list");
 837         return 1;
 838     }
 839
 840     if (seq.len != 0) {
 841         printf("seq not empty!");
 842         return 1;
 843     }
 844     free_TESTSeqOf(&seq);
 845     ret = 0;
 846
 847 out:
 848
 849     return ret;
 850 }
 851
 852 #define test_seq_of(type, ok, ptr)                                      \
 853 {                                                                       \
 854     heim_octet_string os;                                               \
 855     size_t size;                                                        \
 856     type decode;                                                        \
 857     ASN1_MALLOC_ENCODE(type, os.data, os.length, ptr, &size, ret);      \
 858     if (ret)                                                            \
 859         return ret;                                                     \
 860     if (os.length != size)                                              \
 861         abort();                                                        \
 862     ret = decode_##type(os.data, os.length, &decode, &size);            \
 863     free(os.data);                                                      \
 864     if (ret) {                                                          \
 865         if (ok)                                                         \
 866             return 1;                                                   \
 867     } else {                                                            \
 868         free_##type(&decode);                                           \
 869         if (!ok)                                                        \
 870             return 1;                                                   \
 871         if (size != 0)                                                  \
 872             return 1;                                                   \
 873     }                                                                   \
 874     return 0;                                                           \
 875 }
 876
 877 static int
 878 check_seq_of_size(void)
 879 {
 880     TESTInteger integers[4] = { 1, 2, 3, 4 };
 881     int ret;
 882
 883     {
 884         TESTSeqSizeOf1 ssof1f1 = { 1, integers };
 885         TESTSeqSizeOf1 ssof1ok1 = { 2, integers };
 886         TESTSeqSizeOf1 ssof1f2 = { 3, integers };
 887
 888         test_seq_of(TESTSeqSizeOf1, 0, &ssof1f1);
 889         test_seq_of(TESTSeqSizeOf1, 1, &ssof1ok1);
 890         test_seq_of(TESTSeqSizeOf1, 0, &ssof1f2);
 891     }
 892     {
 893         TESTSeqSizeOf2 ssof2f1 = { 0, NULL };
 894         TESTSeqSizeOf2 ssof2ok1 = { 1, integers };
 895         TESTSeqSizeOf2 ssof2ok2 = { 2, integers };
 896         TESTSeqSizeOf2 ssof2f2 = { 3, integers };
 897
 898         test_seq_of(TESTSeqSizeOf2, 0, &ssof2f1);
 899         test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok1);
 900         test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok2);
 901         test_seq_of(TESTSeqSizeOf2, 0, &ssof2f2);
 902     }
 903     {
 904         TESTSeqSizeOf3 ssof3f1 = { 0, NULL };
 905         TESTSeqSizeOf3 ssof3ok1 = { 1, integers };
 906         TESTSeqSizeOf3 ssof3ok2 = { 2, integers };
 907
 908         test_seq_of(TESTSeqSizeOf3, 0, &ssof3f1);
 909         test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok1);
 910         test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok2);
 911     }
 912     {
 913         TESTSeqSizeOf4 ssof4ok1 = { 0, NULL };
 914         TESTSeqSizeOf4 ssof4ok2 = { 1, integers };
 915         TESTSeqSizeOf4 ssof4ok3 = { 2, integers };
 916         TESTSeqSizeOf4 ssof4f1  = { 3, integers };
 917
 918         test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok1);
 919         test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok2);
 920         test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok3);
 921         test_seq_of(TESTSeqSizeOf4, 0, &ssof4f1);
 922    }
 923
 924     return 0;
 925 }
 926
 927
 928
 929 int
 930 main(int argc, char **argv)
 931 {
 932     int ret = 0;
 933
 934     ret += test_principal ();
 935     ret += test_authenticator();
 936     ret += test_krb_error();
 937     ret += test_Name();
 938     ret += test_bit_string();
 939
 940     ret += check_tag_length();
 941     ret += test_large_tag();
 942     ret += test_choice();
 943
 944     ret += test_implicit();
 945     ret += test_taglessalloc();
 946
 947     ret += check_fail_largetag();
 948     ret += check_fail_sequence();
 949     ret += check_fail_choice();
 950
 951     ret += check_seq();
 952     ret += check_seq_of_size();
 953
 954     return ret;
 955 }