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

   1 /*
   2  * Copyright (c) 1999 - 2007 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 #include "der_locl.h"
  35 #include <err.h>
  36 #include <roken.h>
  37
  38 #include <asn1-common.h>
  39 #include <asn1_err.h>
  40 #include <der.h>
  41
  42 #include "check-common.h"
  43
  44 RCSID("$Id: check-der.c 21359 2007-06-27 08:15:41Z lha $");
  45
  46 static int
  47 cmp_integer (void *a, void *b)
  48 {
  49     int *ia = (int *)a;
  50     int *ib = (int *)b;
  51
  52     return *ib - *ia;
  53 }
  54
  55 static int
  56 test_integer (void)
  57 {
  58     struct test_case tests[] = {
  59         {NULL, 1, "\x00"},
  60         {NULL, 1, "\x7f"},
  61         {NULL, 2, "\x00\x80"},
  62         {NULL, 2, "\x01\x00"},
  63         {NULL, 1, "\x80"},
  64         {NULL, 2, "\xff\x7f"},
  65         {NULL, 1, "\xff"},
  66         {NULL, 2, "\xff\x01"},
  67         {NULL, 2, "\x00\xff"},
  68         {NULL, 4, "\x7f\xff\xff\xff"}
  69     };
  70
  71     int values[] = {0, 127, 128, 256, -128, -129, -1, -255, 255,
  72                     0x7fffffff};
  73     int i, ret;
  74     int ntests = sizeof(tests) / sizeof(*tests);
  75
  76     for (i = 0; i < ntests; ++i) {
  77         tests[i].val = &values[i];
  78         asprintf (&tests[i].name, "integer %d", values[i]);
  79         if (tests[i].name == NULL)
  80             errx(1, "malloc");
  81     }
  82
  83     ret = generic_test (tests, ntests, sizeof(int),
  84                         (generic_encode)der_put_integer,
  85                          (generic_length) der_length_integer,
  86                          (generic_decode)der_get_integer,
  87                          (generic_free)NULL,
  88                          cmp_integer);
  89
  90     for (i = 0; i < ntests; ++i)
  91         free (tests[i].name);
  92     return ret;
  93 }
  94
  95 static int
  96 test_one_int(int val)
  97 {
  98     int ret, dval;
  99     unsigned char *buf;
 100     size_t len_len, len;
 101
 102     len = _heim_len_int(val);
 103
 104     buf = emalloc(len + 2);
 105
 106     buf[0] = '\xff';
 107     buf[len + 1] = '\xff';
 108     memset(buf + 1, 0, len);
 109
 110     ret = der_put_integer(buf + 1 + len - 1, len, &val, &len_len);
 111     if (ret) {
 112         printf("integer %d encode failed %d\n", val, ret);
 113         return 1;
 114     }
 115     if (len != len_len) {
 116         printf("integer %d encode fail with %d len %lu, result len %lu\n",
 117                val, ret, (unsigned long)len, (unsigned long)len_len);
 118         return 1;
 119     }
 120
 121     ret = der_get_integer(buf + 1, len, &dval, &len_len);
 122     if (ret) {
 123         printf("integer %d decode failed %d\n", val, ret);
 124         return 1;
 125     }
 126     if (len != len_len) {
 127         printf("integer %d decoded diffrent len %lu != %lu",
 128                val, (unsigned long)len, (unsigned long)len_len);
 129         return 1;
 130     }
 131     if (val != dval) {
 132         printf("decode decoded to diffrent value %d != %d",
 133                val, dval);
 134         return 1;
 135     }
 136
 137     if (buf[0] != (unsigned char)'\xff') {
 138         printf("precanary dead %d\n", val);
 139         return 1;
 140     }
 141     if (buf[len + 1] != (unsigned char)'\xff') {
 142         printf("postecanary dead %d\n", val);
 143         return 1;
 144     }
 145     free(buf);
 146     return 0;
 147 }
 148
 149 static int
 150 test_integer_more (void)
 151 {
 152     int i, n1, n2, n3, n4, n5, n6;
 153
 154     n2 = 0;
 155     for (i = 0; i < (sizeof(int) * 8); i++) {
 156         n1 = 0x01 << i;
 157         n2 = n2 | n1;
 158         n3 = ~n1;
 159         n4 = ~n2;
 160         n5 = (-1) & ~(0x3f << i);
 161         n6 = (-1) & ~(0x7f << i);
 162
 163         test_one_int(n1);
 164         test_one_int(n2);
 165         test_one_int(n3);
 166         test_one_int(n4);
 167         test_one_int(n5);
 168         test_one_int(n6);
 169     }
 170     return 0;
 171 }
 172
 173 static int
 174 cmp_unsigned (void *a, void *b)
 175 {
 176     return *(unsigned int*)b - *(unsigned int*)a;
 177 }
 178
 179 static int
 180 test_unsigned (void)
 181 {
 182     struct test_case tests[] = {
 183         {NULL, 1, "\x00"},
 184         {NULL, 1, "\x7f"},
 185         {NULL, 2, "\x00\x80"},
 186         {NULL, 2, "\x01\x00"},
 187         {NULL, 2, "\x02\x00"},
 188         {NULL, 3, "\x00\x80\x00"},
 189         {NULL, 5, "\x00\x80\x00\x00\x00"},
 190         {NULL, 4, "\x7f\xff\xff\xff"}
 191     };
 192
 193     unsigned int values[] = {0, 127, 128, 256, 512, 32768,
 194                              0x80000000, 0x7fffffff};
 195     int i, ret;
 196     int ntests = sizeof(tests) / sizeof(*tests);
 197
 198     for (i = 0; i < ntests; ++i) {
 199         tests[i].val = &values[i];
 200         asprintf (&tests[i].name, "unsigned %u", values[i]);
 201         if (tests[i].name == NULL)
 202             errx(1, "malloc");
 203     }
 204
 205     ret = generic_test (tests, ntests, sizeof(int),
 206                         (generic_encode)der_put_unsigned,
 207                         (generic_length)der_length_unsigned,
 208                         (generic_decode)der_get_unsigned,
 209                         (generic_free)NULL,
 210                         cmp_unsigned);
 211     for (i = 0; i < ntests; ++i)
 212         free (tests[i].name);
 213     return ret;
 214 }
 215
 216 static int
 217 cmp_octet_string (void *a, void *b)
 218 {
 219     heim_octet_string *oa = (heim_octet_string *)a;
 220     heim_octet_string *ob = (heim_octet_string *)b;
 221
 222     if (oa->length != ob->length)
 223         return ob->length - oa->length;
 224
 225     return (memcmp (oa->data, ob->data, oa->length));
 226 }
 227
 228 static int
 229 test_octet_string (void)
 230 {
 231     heim_octet_string s1 = {8, "\x01\x23\x45\x67\x89\xab\xcd\xef"};
 232
 233     struct test_case tests[] = {
 234         {NULL, 8, "\x01\x23\x45\x67\x89\xab\xcd\xef"}
 235     };
 236     int ntests = sizeof(tests) / sizeof(*tests);
 237     int ret;
 238
 239     tests[0].val = &s1;
 240     asprintf (&tests[0].name, "a octet string");
 241     if (tests[0].name == NULL)
 242         errx(1, "malloc");
 243
 244     ret = generic_test (tests, ntests, sizeof(heim_octet_string),
 245                         (generic_encode)der_put_octet_string,
 246                         (generic_length)der_length_octet_string,
 247                         (generic_decode)der_get_octet_string,
 248                         (generic_free)der_free_octet_string,
 249                         cmp_octet_string);
 250     free(tests[0].name);
 251     return ret;
 252 }
 253
 254 static int
 255 cmp_bmp_string (void *a, void *b)
 256 {
 257     heim_bmp_string *oa = (heim_bmp_string *)a;
 258     heim_bmp_string *ob = (heim_bmp_string *)b;
 259
 260     return der_heim_bmp_string_cmp(oa, ob);
 261 }
 262
 263 static uint16_t bmp_d1[] = { 32 };
 264 static uint16_t bmp_d2[] = { 32, 32 };
 265
 266 static int
 267 test_bmp_string (void)
 268 {
 269     heim_bmp_string s1 = { 1, bmp_d1 };
 270     heim_bmp_string s2 = { 2, bmp_d2 };
 271
 272     struct test_case tests[] = {
 273         {NULL, 2, "\x00\x20"},
 274         {NULL, 4, "\x00\x20\x00\x20"}
 275     };
 276     int ntests = sizeof(tests) / sizeof(*tests);
 277     int ret;
 278
 279     tests[0].val = &s1;
 280     asprintf (&tests[0].name, "a bmp string");
 281     if (tests[0].name == NULL)
 282         errx(1, "malloc");
 283     tests[1].val = &s2;
 284     asprintf (&tests[1].name, "second bmp string");
 285     if (tests[1].name == NULL)
 286         errx(1, "malloc");
 287
 288     ret = generic_test (tests, ntests, sizeof(heim_bmp_string),
 289                         (generic_encode)der_put_bmp_string,
 290                         (generic_length)der_length_bmp_string,
 291                         (generic_decode)der_get_bmp_string,
 292                         (generic_free)der_free_bmp_string,
 293                         cmp_bmp_string);
 294     free(tests[0].name);
 295     free(tests[1].name);
 296     return ret;
 297 }
 298
 299 static int
 300 cmp_universal_string (void *a, void *b)
 301 {
 302     heim_universal_string *oa = (heim_universal_string *)a;
 303     heim_universal_string *ob = (heim_universal_string *)b;
 304
 305     return der_heim_universal_string_cmp(oa, ob);
 306 }
 307
 308 static uint32_t universal_d1[] = { 32 };
 309 static uint32_t universal_d2[] = { 32, 32 };
 310
 311 static int
 312 test_universal_string (void)
 313 {
 314     heim_universal_string s1 = { 1, universal_d1 };
 315     heim_universal_string s2 = { 2, universal_d2 };
 316
 317     struct test_case tests[] = {
 318         {NULL, 4, "\x00\x00\x00\x20"},
 319         {NULL, 8, "\x00\x00\x00\x20\x00\x00\x00\x20"}
 320     };
 321     int ntests = sizeof(tests) / sizeof(*tests);
 322     int ret;
 323
 324     tests[0].val = &s1;
 325     asprintf (&tests[0].name, "a universal string");
 326     if (tests[0].name == NULL)
 327         errx(1, "malloc");
 328     tests[1].val = &s2;
 329     asprintf (&tests[1].name, "second universal string");
 330     if (tests[1].name == NULL)
 331         errx(1, "malloc");
 332
 333     ret = generic_test (tests, ntests, sizeof(heim_universal_string),
 334                         (generic_encode)der_put_universal_string,
 335                         (generic_length)der_length_universal_string,
 336                         (generic_decode)der_get_universal_string,
 337                         (generic_free)der_free_universal_string,
 338                         cmp_universal_string);
 339     free(tests[0].name);
 340     free(tests[1].name);
 341     return ret;
 342 }
 343
 344 static int
 345 cmp_general_string (void *a, void *b)
 346 {
 347     char **sa = (char **)a;
 348     char **sb = (char **)b;
 349
 350     return strcmp (*sa, *sb);
 351 }
 352
 353 static int
 354 test_general_string (void)
 355 {
 356     char *s1 = "Test User 1";
 357
 358     struct test_case tests[] = {
 359         {NULL, 11, "\x54\x65\x73\x74\x20\x55\x73\x65\x72\x20\x31"}
 360     };
 361     int ret, ntests = sizeof(tests) / sizeof(*tests);
 362
 363     tests[0].val = &s1;
 364     asprintf (&tests[0].name, "the string \"%s\"", s1);
 365     if (tests[0].name == NULL)
 366         errx(1, "malloc");
 367
 368     ret = generic_test (tests, ntests, sizeof(unsigned char *),
 369                         (generic_encode)der_put_general_string,
 370                         (generic_length)der_length_general_string,
 371                         (generic_decode)der_get_general_string,
 372                         (generic_free)der_free_general_string,
 373                         cmp_general_string);
 374     free(tests[0].name);
 375     return ret;
 376 }
 377
 378 static int
 379 cmp_generalized_time (void *a, void *b)
 380 {
 381     time_t *ta = (time_t *)a;
 382     time_t *tb = (time_t *)b;
 383
 384     return *tb - *ta;
 385 }
 386
 387 static int
 388 test_generalized_time (void)
 389 {
 390     struct test_case tests[] = {
 391         {NULL, 15, "19700101000000Z"},
 392         {NULL, 15, "19851106210627Z"}
 393     };
 394     time_t values[] = {0, 500159187};
 395     int i, ret;
 396     int ntests = sizeof(tests) / sizeof(*tests);
 397
 398     for (i = 0; i < ntests; ++i) {
 399         tests[i].val = &values[i];
 400         asprintf (&tests[i].name, "time %d", (int)values[i]);
 401         if (tests[i].name == NULL)
 402             errx(1, "malloc");
 403     }
 404
 405     ret = generic_test (tests, ntests, sizeof(time_t),
 406                         (generic_encode)der_put_generalized_time,
 407                         (generic_length)der_length_generalized_time,
 408                         (generic_decode)der_get_generalized_time,
 409                         (generic_free)NULL,
 410                         cmp_generalized_time);
 411     for (i = 0; i < ntests; ++i)
 412         free(tests[i].name);
 413     return ret;
 414 }
 415
 416 static int
 417 test_cmp_oid (void *a, void *b)
 418 {
 419     return der_heim_oid_cmp((heim_oid *)a, (heim_oid *)b);
 420 }
 421
 422 static unsigned oid_comp1[] = { 1, 1, 1 };
 423 static unsigned oid_comp2[] = { 1, 1 };
 424 static unsigned oid_comp3[] = { 6, 15, 1 };
 425 static unsigned oid_comp4[] = { 6, 15 };
 426
 427 static int
 428 test_oid (void)
 429 {
 430     struct test_case tests[] = {
 431         {NULL, 2, "\x29\x01"},
 432         {NULL, 1, "\x29"},
 433         {NULL, 2, "\xff\x01"},
 434         {NULL, 1, "\xff"}
 435     };
 436     heim_oid values[] = {
 437         { 3, oid_comp1 },
 438         { 2, oid_comp2 },
 439         { 3, oid_comp3 },
 440         { 2, oid_comp4 }
 441     };
 442     int i, ret;
 443     int ntests = sizeof(tests) / sizeof(*tests);
 444
 445     for (i = 0; i < ntests; ++i) {
 446         tests[i].val = &values[i];
 447         asprintf (&tests[i].name, "oid %d", i);
 448         if (tests[i].name == NULL)
 449             errx(1, "malloc");
 450     }
 451
 452     ret = generic_test (tests, ntests, sizeof(heim_oid),
 453                         (generic_encode)der_put_oid,
 454                         (generic_length)der_length_oid,
 455                         (generic_decode)der_get_oid,
 456                         (generic_free)der_free_oid,
 457                         test_cmp_oid);
 458     for (i = 0; i < ntests; ++i)
 459         free(tests[i].name);
 460     return ret;
 461 }
 462
 463 static int
 464 test_cmp_bit_string (void *a, void *b)
 465 {
 466     return der_heim_bit_string_cmp((heim_bit_string *)a, (heim_bit_string *)b);
 467 }
 468
 469 static int
 470 test_bit_string (void)
 471 {
 472     struct test_case tests[] = {
 473         {NULL, 1, "\x00"}
 474     };
 475     heim_bit_string values[] = {
 476         { 0, "" }
 477     };
 478     int i, ret;
 479     int ntests = sizeof(tests) / sizeof(*tests);
 480
 481     for (i = 0; i < ntests; ++i) {
 482         tests[i].val = &values[i];
 483         asprintf (&tests[i].name, "bit_string %d", i);
 484         if (tests[i].name == NULL)
 485             errx(1, "malloc");
 486     }
 487
 488     ret = generic_test (tests, ntests, sizeof(heim_bit_string),
 489                         (generic_encode)der_put_bit_string,
 490                         (generic_length)der_length_bit_string,
 491                         (generic_decode)der_get_bit_string,
 492                         (generic_free)der_free_bit_string,
 493                         test_cmp_bit_string);
 494     for (i = 0; i < ntests; ++i)
 495         free(tests[i].name);
 496     return ret;
 497 }
 498
 499 static int
 500 test_cmp_heim_integer (void *a, void *b)
 501 {
 502     return der_heim_integer_cmp((heim_integer *)a, (heim_integer *)b);
 503 }
 504
 505 static int
 506 test_heim_integer (void)
 507 {
 508     struct test_case tests[] = {
 509         {NULL, 2, "\xfe\x01"},
 510         {NULL, 2, "\xef\x01"},
 511         {NULL, 3, "\xff\x00\xff"},
 512         {NULL, 3, "\xff\x01\x00"},
 513         {NULL, 1, "\x00"},
 514         {NULL, 1, "\x01"},
 515         {NULL, 2, "\x00\x80"}
 516     };
 517
 518     heim_integer values[] = {
 519         { 2, "\x01\xff", 1 },
 520         { 2, "\x10\xff", 1 },
 521         { 2, "\xff\x01", 1 },
 522         { 2, "\xff\x00", 1 },
 523         { 0, "", 0 },
 524         { 1, "\x01", 0 },
 525         { 1, "\x80", 0 }
 526     };
 527     int i, ret;
 528     int ntests = sizeof(tests) / sizeof(tests[0]);
 529     size_t size;
 530     heim_integer i2;
 531
 532     for (i = 0; i < ntests; ++i) {
 533         tests[i].val = &values[i];
 534         asprintf (&tests[i].name, "heim_integer %d", i);
 535         if (tests[i].name == NULL)
 536             errx(1, "malloc");
 537     }
 538
 539     ret = generic_test (tests, ntests, sizeof(heim_integer),
 540                         (generic_encode)der_put_heim_integer,
 541                         (generic_length)der_length_heim_integer,
 542                         (generic_decode)der_get_heim_integer,
 543                         (generic_free)der_free_heim_integer,
 544                         test_cmp_heim_integer);
 545     for (i = 0; i < ntests; ++i)
 546         free (tests[i].name);
 547     if (ret)
 548         return ret;
 549
 550     /* test zero length integer (BER format) */
 551     ret = der_get_heim_integer(NULL, 0, &i2, &size);
 552     if (ret)
 553         errx(1, "der_get_heim_integer");
 554     if (i2.length != 0)
 555         errx(1, "der_get_heim_integer wrong length");
 556     der_free_heim_integer(&i2);
 557
 558     return 0;
 559 }
 560
 561 static int
 562 test_cmp_boolean (void *a, void *b)
 563 {
 564     return !!*(int *)a != !!*(int *)b;
 565 }
 566
 567 static int
 568 test_boolean (void)
 569 {
 570     struct test_case tests[] = {
 571         {NULL, 1, "\xff"},
 572         {NULL, 1, "\x00"}
 573     };
 574
 575     int values[] = { 1, 0 };
 576     int i, ret;
 577     int ntests = sizeof(tests) / sizeof(tests[0]);
 578     size_t size;
 579     heim_integer i2;
 580
 581     for (i = 0; i < ntests; ++i) {
 582         tests[i].val = &values[i];
 583         asprintf (&tests[i].name, "heim_boolean %d", i);
 584         if (tests[i].name == NULL)
 585             errx(1, "malloc");
 586     }
 587
 588     ret = generic_test (tests, ntests, sizeof(int),
 589                         (generic_encode)der_put_boolean,
 590                         (generic_length)der_length_boolean,
 591                         (generic_decode)der_get_boolean,
 592                         (generic_free)NULL,
 593                         test_cmp_boolean);
 594     for (i = 0; i < ntests; ++i)
 595         free (tests[i].name);
 596     if (ret)
 597         return ret;
 598
 599     /* test zero length integer (BER format) */
 600     ret = der_get_heim_integer(NULL, 0, &i2, &size);
 601     if (ret)
 602         errx(1, "der_get_heim_integer");
 603     if (i2.length != 0)
 604         errx(1, "der_get_heim_integer wrong length");
 605     der_free_heim_integer(&i2);
 606
 607     return 0;
 608 }
 609
 610 static int
 611 check_fail_unsigned(void)
 612 {
 613     struct test_case tests[] = {
 614         {NULL, sizeof(unsigned) + 1,
 615          "\x01\x01\x01\x01\x01\x01\x01\x01\x01", "data overrun" }
 616     };
 617     int ntests = sizeof(tests) / sizeof(*tests);
 618
 619     return generic_decode_fail(tests, ntests, sizeof(unsigned),
 620                                (generic_decode)der_get_unsigned);
 621 }
 622
 623 static int
 624 check_fail_integer(void)
 625 {
 626     struct test_case tests[] = {
 627         {NULL, sizeof(int) + 1,
 628          "\x01\x01\x01\x01\x01\x01\x01\x01\x01", "data overrun" }
 629     };
 630     int ntests = sizeof(tests) / sizeof(*tests);
 631
 632     return generic_decode_fail(tests, ntests, sizeof(int),
 633                                (generic_decode)der_get_integer);
 634 }
 635
 636 static int
 637 check_fail_length(void)
 638 {
 639     struct test_case tests[] = {
 640         {NULL, 0, "", "empty input data"},
 641         {NULL, 1, "\x82", "internal length overrun" }
 642     };
 643     int ntests = sizeof(tests) / sizeof(*tests);
 644
 645     return generic_decode_fail(tests, ntests, sizeof(size_t),
 646                                (generic_decode)der_get_length);
 647 }
 648
 649 static int
 650 check_fail_boolean(void)
 651 {
 652     struct test_case tests[] = {
 653         {NULL, 0, "", "empty input data"}
 654     };
 655     int ntests = sizeof(tests) / sizeof(*tests);
 656
 657     return generic_decode_fail(tests, ntests, sizeof(int),
 658                                (generic_decode)der_get_boolean);
 659 }
 660
 661 static int
 662 check_fail_general_string(void)
 663 {
 664     struct test_case tests[] = {
 665         { NULL, 3, "A\x00i", "NUL char in string"}
 666     };
 667     int ntests = sizeof(tests) / sizeof(*tests);
 668
 669     return generic_decode_fail(tests, ntests, sizeof(heim_general_string),
 670                                (generic_decode)der_get_general_string);
 671 }
 672
 673 static int
 674 check_fail_bmp_string(void)
 675 {
 676     struct test_case tests[] = {
 677         {NULL, 1, "\x00", "odd (1) length bmpstring"},
 678         {NULL, 3, "\x00\x00\x00", "odd (3) length bmpstring"}
 679     };
 680     int ntests = sizeof(tests) / sizeof(*tests);
 681
 682     return generic_decode_fail(tests, ntests, sizeof(heim_bmp_string),
 683                                (generic_decode)der_get_bmp_string);
 684 }
 685
 686 static int
 687 check_fail_universal_string(void)
 688 {
 689     struct test_case tests[] = {
 690         {NULL, 1, "\x00", "x & 3 == 1 universal string"},
 691         {NULL, 2, "\x00\x00", "x & 3 == 2 universal string"},
 692         {NULL, 3, "\x00\x00\x00", "x & 3 == 3 universal string"},
 693         {NULL, 5, "\x00\x00\x00\x00\x00", "x & 3 == 1 universal string"},
 694         {NULL, 6, "\x00\x00\x00\x00\x00\x00", "x & 3 == 2 universal string"},
 695         {NULL, 7, "\x00\x00\x00\x00\x00\x00\x00", "x & 3 == 3 universal string"}
 696     };
 697     int ntests = sizeof(tests) / sizeof(*tests);
 698
 699     return generic_decode_fail(tests, ntests, sizeof(heim_universal_string),
 700                                (generic_decode)der_get_universal_string);
 701 }
 702
 703 static int
 704 check_fail_heim_integer(void)
 705 {
 706 #if 0
 707     struct test_case tests[] = {
 708     };
 709     int ntests = sizeof(tests) / sizeof(*tests);
 710
 711     return generic_decode_fail(tests, ntests, sizeof(heim_integer),
 712                                (generic_decode)der_get_heim_integer);
 713 #else
 714     return 0;
 715 #endif
 716 }
 717
 718 static int
 719 check_fail_generalized_time(void)
 720 {
 721     struct test_case tests[] = {
 722         {NULL, 1, "\x00", "no time"}
 723     };
 724     int ntests = sizeof(tests) / sizeof(*tests);
 725
 726     return generic_decode_fail(tests, ntests, sizeof(time_t),
 727                                (generic_decode)der_get_generalized_time);
 728 }
 729
 730 static int
 731 check_fail_oid(void)
 732 {
 733     struct test_case tests[] = {
 734         {NULL, 0, "", "empty input data"},
 735         {NULL, 2, "\x00\x80", "last byte continuation" },
 736         {NULL, 11, "\x00\x81\x80\x80\x80\x80\x80\x80\x80\x80\x00",
 737         "oid element overflow" }
 738     };
 739     int ntests = sizeof(tests) / sizeof(*tests);
 740
 741     return generic_decode_fail(tests, ntests, sizeof(heim_oid),
 742                                (generic_decode)der_get_oid);
 743 }
 744
 745 static int
 746 check_fail_bitstring(void)
 747 {
 748     struct test_case tests[] = {
 749         {NULL, 0, "", "empty input data"},
 750         {NULL, 1, "\x08", "larger then 8 bits trailer"},
 751         {NULL, 1, "\x01", "to few bytes for bits"},
 752         {NULL, -2, "\x00", "length overrun"},
 753         {NULL, -1, "", "length to short"}
 754     };
 755     int ntests = sizeof(tests) / sizeof(*tests);
 756
 757     return generic_decode_fail(tests, ntests, sizeof(heim_bit_string),
 758                                (generic_decode)der_get_bit_string);
 759 }
 760
 761 static int
 762 check_heim_integer_same(const char *p, const char *norm_p, heim_integer *i)
 763 {
 764     heim_integer i2;
 765     char *str;
 766     int ret;
 767
 768     ret = der_print_hex_heim_integer(i, &str);
 769     if (ret)
 770         errx(1, "der_print_hex_heim_integer: %d", ret);
 771
 772     if (strcmp(str, norm_p) != 0)
 773         errx(1, "der_print_hex_heim_integer: %s != %s", str, p);
 774
 775     ret = der_parse_hex_heim_integer(str, &i2);
 776     if (ret)
 777         errx(1, "der_parse_hex_heim_integer: %d", ret);
 778
 779     if (der_heim_integer_cmp(i, &i2) != 0)
 780         errx(1, "der_heim_integer_cmp: p %s", p);
 781
 782     der_free_heim_integer(&i2);
 783     free(str);
 784
 785     ret = der_parse_hex_heim_integer(p, &i2);
 786     if (ret)
 787         errx(1, "der_parse_hex_heim_integer: %d", ret);
 788
 789     if (der_heim_integer_cmp(i, &i2) != 0)
 790         errx(1, "der_heim_integer_cmp: norm");
 791
 792     der_free_heim_integer(&i2);
 793
 794     return 0;
 795 }
 796
 797 static int
 798 test_heim_int_format(void)
 799 {
 800     heim_integer i = { 1, "\x10", 0 };
 801     heim_integer i2 = { 1, "\x10", 1 };
 802     heim_integer i3 = { 1, "\01", 0 };
 803     char *p =
 804         "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1"
 805         "29024E08" "8A67CC74" "020BBEA6" "3B139B22" "514A0879" "8E3404DD"
 806         "EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" "4FE1356D" "6D51C245"
 807         "E485B576" "625E7EC6" "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED"
 808         "EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" "49286651" "ECE65381"
 809         "FFFFFFFF" "FFFFFFFF";
 810     heim_integer bni = {
 811         128,
 812         "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC9\x0F\xDA\xA2"
 813         "\x21\x68\xC2\x34\xC4\xC6\x62\x8B\x80\xDC\x1C\xD1"
 814         "\x29\x02\x4E\x08\x8A\x67\xCC\x74\x02\x0B\xBE\xA6"
 815         "\x3B\x13\x9B\x22\x51\x4A\x08\x79\x8E\x34\x04\xDD"
 816         "\xEF\x95\x19\xB3\xCD\x3A\x43\x1B\x30\x2B\x0A\x6D"
 817         "\xF2\x5F\x14\x37\x4F\xE1\x35\x6D\x6D\x51\xC2\x45"
 818         "\xE4\x85\xB5\x76\x62\x5E\x7E\xC6\xF4\x4C\x42\xE9"
 819         "\xA6\x37\xED\x6B\x0B\xFF\x5C\xB6\xF4\x06\xB7\xED"
 820         "\xEE\x38\x6B\xFB\x5A\x89\x9F\xA5\xAE\x9F\x24\x11"
 821         "\x7C\x4B\x1F\xE6\x49\x28\x66\x51\xEC\xE6\x53\x81"
 822         "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
 823         0
 824     };
 825     heim_integer f;
 826     int ret = 0;
 827
 828     ret += check_heim_integer_same(p, p, &bni);
 829     ret += check_heim_integer_same("10", "10", &i);
 830     ret += check_heim_integer_same("00000010", "10", &i);
 831     ret += check_heim_integer_same("-10", "-10", &i2);
 832     ret += check_heim_integer_same("-00000010", "-10", &i2);
 833     ret += check_heim_integer_same("01", "01", &i3);
 834     ret += check_heim_integer_same("1", "01", &i3);
 835
 836     {
 837         int r;
 838         r = der_parse_hex_heim_integer("-", &f);
 839         if (r == 0) {
 840             der_free_heim_integer(&f);
 841             ret++;
 842         }
 843         /* used to cause UMR */
 844         r = der_parse_hex_heim_integer("00", &f);
 845         if (r == 0)
 846             der_free_heim_integer(&f);
 847         else
 848             ret++;
 849     }
 850
 851     return ret;
 852 }
 853
 854 static int
 855 test_heim_oid_format_same(const char *str, const heim_oid *oid)
 856 {
 857     int ret;
 858     char *p;
 859     heim_oid o2;
 860
 861     ret = der_print_heim_oid(oid, ' ', &p);
 862     if (ret) {
 863         printf("fail to print oid: %s\n", str);
 864         return 1;
 865     }
 866     ret = strcmp(p, str);
 867     if (ret) {
 868         printf("oid %s != formated oid %s\n", str, p);
 869         free(p);
 870         return ret;
 871     }
 872
 873     ret = der_parse_heim_oid(p, " ", &o2);
 874     if (ret) {
 875         printf("failed to parse %s\n", p);
 876         free(p);
 877         return ret;
 878     }
 879     free(p);
 880     ret = der_heim_oid_cmp(&o2, oid);
 881     der_free_oid(&o2);
 882
 883     return ret;
 884 }
 885
 886 static unsigned sha1_oid_tree[] = { 1, 3, 14, 3, 2, 26 };
 887
 888 static int
 889 test_heim_oid_format(void)
 890 {
 891     heim_oid sha1 = { 6, sha1_oid_tree };
 892     int ret = 0;
 893
 894     ret += test_heim_oid_format_same("1 3 14 3 2 26", &sha1);
 895
 896     return ret;
 897 }
 898
 899 static int
 900 check_trailing_nul(void)
 901 {
 902     int i, ret;
 903     struct {
 904         int fail;
 905         const unsigned char *p;
 906         size_t len;
 907         const char *s;
 908         size_t size;
 909     } foo[] = {
 910         { 1, (const unsigned char *)"foo\x00o", 5, NULL, 0 },
 911         { 1, (const unsigned char *)"\x00o", 2, NULL, 0 },
 912         { 0, (const unsigned char *)"\x00\x00\x00\x00\x00", 5, "", 5 },
 913         { 0, (const unsigned char *)"\x00", 1, "", 1 },
 914         { 0, (const unsigned char *)"", 0, "", 0 },
 915         { 0, (const unsigned char *)"foo\x00\x00", 5, "foo", 5 },
 916         { 0, (const unsigned char *)"foo\0", 4, "foo", 4 },
 917         { 0, (const unsigned char *)"foo", 3, "foo", 3 }
 918     };
 919
 920     for (i = 0; i < sizeof(foo)/sizeof(foo[0]); i++) {
 921         char *s;
 922         size_t size;
 923         ret = der_get_general_string(foo[i].p, foo[i].len, &s, &size);
 924         if (foo[i].fail) {
 925             if (ret == 0)
 926                 errx(1, "check %d NULL didn't fail", i);
 927             continue;
 928         }
 929         if (ret)
 930             errx(1, "NULL check %d der_get_general_string failed", i);
 931         if (foo[i].size != size)
 932             errx(1, "NUL check i = %d size failed", i);
 933         if (strcmp(foo[i].s, s) != 0)
 934             errx(1, "NUL check i = %d content failed", i);
 935         free(s);
 936     }
 937     return 0;
 938 }
 939
 940 static int
 941 test_misc_cmp(void)
 942 {
 943     int ret;
 944
 945     /* diffrent lengths are diffrent */
 946     {
 947         const heim_octet_string os1 = { 1, "a" } , os2 = { 0, NULL };
 948         ret = der_heim_octet_string_cmp(&os1, &os2);
 949         if (ret == 0)
 950             return 1;
 951     }
 952     /* diffrent data are diffrent */
 953     {
 954         const heim_octet_string os1 = { 1, "a" } , os2 = { 1, "b" };
 955         ret = der_heim_octet_string_cmp(&os1, &os2);
 956         if (ret == 0)
 957             return 1;
 958     }
 959     /* diffrent lengths are diffrent */
 960     {
 961         const heim_bit_string bs1 = { 8, "a" } , bs2 = { 7, "a" };
 962         ret = der_heim_bit_string_cmp(&bs1, &bs2);
 963         if (ret == 0)
 964             return 1;
 965     }
 966     /* diffrent data are diffrent */
 967     {
 968         const heim_bit_string bs1 = { 7, "\x0f" } , bs2 = { 7, "\x02" };
 969         ret = der_heim_bit_string_cmp(&bs1, &bs2);
 970         if (ret == 0)
 971             return 1;
 972     }
 973     /* diffrent lengths are diffrent */
 974     {
 975         uint16_t data = 1;
 976         heim_bmp_string bs1 = { 1, NULL } , bs2 = { 0, NULL };
 977         bs1.data = &data;
 978         ret = der_heim_bmp_string_cmp(&bs1, &bs2);
 979         if (ret == 0)
 980             return 1;
 981     }
 982     /* diffrent lengths are diffrent */
 983     {
 984         uint32_t data;
 985         heim_universal_string us1 = { 1, NULL } , us2 = { 0, NULL };
 986         us1.data = &data;
 987         ret = der_heim_universal_string_cmp(&us1, &us2);
 988         if (ret == 0)
 989             return 1;
 990     }
 991     /* same */
 992     {
 993         uint32_t data = (uint32_t)'a';
 994         heim_universal_string us1 = { 1, NULL } , us2 = { 1, NULL };
 995         us1.data = &data;
 996         us2.data = &data;
 997         ret = der_heim_universal_string_cmp(&us1, &us2);
 998         if (ret != 0)
 999             return 1;
1000     }
1001
1002     return 0;
1003 }
1004
1005 static int
1006 corner_generalized_time(void)
1007 {
1008     const char *str = "760520140000Z";
1009     size_t size;
1010     time_t t;
1011     int ret;
1012
1013     ret = der_get_generalized_time((const unsigned char*)str, strlen(str),
1014                                    &t, &size);
1015     if (ret)
1016         return 1;
1017     return 0;
1018 }
1019
1020 static int
1021 corner_tag(void)
1022 {
1023     struct {
1024         int ok;
1025         const char *ptr;
1026         size_t len;
1027     } tests[] = {
1028         { 1, "\x00", 1 },
1029         { 0, "\xff", 1 },
1030         { 0, "\xff\xff\xff\xff\xff\xff\xff\xff", 8 }
1031     };
1032     int i, ret;
1033     Der_class cl;
1034     Der_type ty;
1035     unsigned int tag;
1036     size_t size;
1037
1038     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
1039         ret = der_get_tag((const unsigned char*)tests[i].ptr,
1040                           tests[i].len, &cl, &ty, &tag, &size);
1041         if (ret) {
1042             if (tests[i].ok)
1043                 errx(1, "failed while shouldn't");
1044         } else {
1045             if (!tests[i].ok)
1046                 errx(1, "passed while shouldn't");
1047         }
1048     }
1049     return 0;
1050 }
1051
1052 int
1053 main(int argc, char **argv)
1054 {
1055     int ret = 0;
1056
1057     ret += test_integer ();
1058     ret += test_integer_more();
1059     ret += test_unsigned ();
1060     ret += test_octet_string ();
1061     ret += test_bmp_string ();
1062     ret += test_universal_string ();
1063     ret += test_general_string ();
1064     ret += test_generalized_time ();
1065     ret += test_oid ();
1066     ret += test_bit_string();
1067     ret += test_heim_integer();
1068     ret += test_boolean();
1069
1070     ret += check_fail_unsigned();
1071     ret += check_fail_integer();
1072     ret += check_fail_length();
1073     ret += check_fail_boolean();
1074     ret += check_fail_general_string();
1075     ret += check_fail_bmp_string();
1076     ret += check_fail_universal_string();
1077     ret += check_fail_heim_integer();
1078     ret += check_fail_generalized_time();
1079     ret += check_fail_oid();
1080     ret += check_fail_bitstring();
1081     ret += test_heim_int_format();
1082     ret += test_heim_oid_format();
1083     ret += check_trailing_nul();
1084     ret += test_misc_cmp();
1085     ret += corner_generalized_time();
1086     ret += corner_tag();
1087
1088     return ret;
1089 }