_ Git - BearSSL/blob - test/test_x509.c

   1 /*
   2  * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdint.h>
  29
  30 #ifdef _WIN32
  31 #include <windows.h>
  32 #else
  33 #include <unistd.h>
  34 #endif
  35
  36 #include "bearssl.h"
  37
  38 #define STR(x)    STR_(x)
  39 #define STR_(x)   #x
  40 #ifdef SRCDIRNAME
  41 #define DIRNAME        STR(SRCDIRNAME) "/test/x509"
  42 #else
  43 #define DIRNAME        "test/x509"
  44 #endif
  45 #define CONFFILE       DIRNAME "/alltests.txt"
  46 #define DEFAULT_TIME   "2016-08-30T18:00:00Z"
  47
  48 static void *
  49 xmalloc(size_t len)
  50 {
  51         void *buf;
  52
  53         if (len == 0) {
  54                 return NULL;
  55         }
  56         buf = malloc(len);
  57         if (buf == NULL) {
  58                 fprintf(stderr, "error: cannot allocate %lu byte(s)\n",
  59                         (unsigned long)len);
  60                 exit(EXIT_FAILURE);
  61         }
  62         return buf;
  63 }
  64
  65 static void
  66 xfree(void *buf)
  67 {
  68         if (buf != NULL) {
  69                 free(buf);
  70         }
  71 }
  72
  73 static char *
  74 xstrdup(const char *name)
  75 {
  76         size_t n;
  77         char *s;
  78
  79         if (name == NULL) {
  80                 return NULL;
  81         }
  82         n = strlen(name) + 1;
  83         s = xmalloc(n);
  84         memcpy(s, name, n);
  85         return s;
  86 }
  87
  88 typedef struct {
  89         char *buf;
  90         size_t ptr, len;
  91 } string_builder;
  92
  93 static string_builder *
  94 SB_new(void)
  95 {
  96         string_builder *sb;
  97
  98         sb = xmalloc(sizeof *sb);
  99         sb->len = 8;
 100         sb->buf = xmalloc(sb->len);
 101         sb->ptr = 0;
 102         return sb;
 103 }
 104
 105 static void
 106 SB_expand(string_builder *sb, size_t extra_len)
 107 {
 108         size_t nlen;
 109         char *nbuf;
 110
 111         if (extra_len < (sb->len - sb->ptr)) {
 112                 return;
 113         }
 114         nlen = sb->len << 1;
 115         if (extra_len > (nlen - sb->ptr)) {
 116                 nlen = sb->ptr + extra_len;
 117         }
 118         nbuf = xmalloc(nlen);
 119         memcpy(nbuf, sb->buf, sb->ptr);
 120         xfree(sb->buf);
 121         sb->buf = nbuf;
 122         sb->len = nlen;
 123 }
 124
 125 static void
 126 SB_append_char(string_builder *sb, int c)
 127 {
 128         SB_expand(sb, 1);
 129         sb->buf[sb->ptr ++] = c;
 130 }
 131
 132 /* unused
 133 static void
 134 SB_append_string(string_builder *sb, const char *s)
 135 {
 136         size_t n;
 137
 138         n = strlen(s);
 139         SB_expand(sb, n);
 140         memcpy(sb->buf + sb->ptr, s, n);
 141         sb->ptr += n;
 142 }
 143 */
 144
 145 /* unused
 146 static char *
 147 SB_to_string(string_builder *sb)
 148 {
 149         char *s;
 150
 151         s = xmalloc(sb->ptr + 1);
 152         memcpy(s, sb->buf, sb->ptr);
 153         s[sb->ptr] = 0;
 154         return s;
 155 }
 156 */
 157
 158 static char *
 159 SB_contents(string_builder *sb)
 160 {
 161         return sb->buf;
 162 }
 163
 164 static size_t
 165 SB_length(string_builder *sb)
 166 {
 167         return sb->ptr;
 168 }
 169
 170 static void
 171 SB_set_length(string_builder *sb, size_t len)
 172 {
 173         if (sb->ptr < len) {
 174                 SB_expand(sb, len - sb->ptr);
 175                 memset(sb->buf + sb->ptr, ' ', len - sb->ptr);
 176         }
 177         sb->ptr = len;
 178 }
 179
 180 static void
 181 SB_reset(string_builder *sb)
 182 {
 183         SB_set_length(sb, 0);
 184 }
 185
 186 static void
 187 SB_free(string_builder *sb)
 188 {
 189         xfree(sb->buf);
 190         xfree(sb);
 191 }
 192
 193 typedef struct ht_elt_ {
 194         char *name;
 195         void *value;
 196         struct ht_elt_ *next;
 197 } ht_elt;
 198
 199 typedef struct {
 200         size_t size;
 201         ht_elt **buckets;
 202         size_t num_buckets;
 203 } HT;
 204
 205 static HT *
 206 HT_new(void)
 207 {
 208         HT *ht;
 209         size_t u;
 210
 211         ht = xmalloc(sizeof *ht);
 212         ht->size = 0;
 213         ht->num_buckets = 8;
 214         ht->buckets = xmalloc(ht->num_buckets * sizeof(ht_elt *));
 215         for (u = 0; u < ht->num_buckets; u ++) {
 216                 ht->buckets[u] = NULL;
 217         }
 218         return ht;
 219 }
 220
 221 static uint32_t
 222 hash_string(const char *name)
 223 {
 224         uint32_t hc;
 225
 226         hc = 0;
 227         while (*name) {
 228                 int x;
 229
 230                 hc = (hc << 5) - hc;
 231                 x = *(const unsigned char *)name;
 232                 if (x >= 'A' && x <= 'Z') {
 233                         x += 'a' - 'A';
 234                 }
 235                 hc += (uint32_t)x;
 236                 name ++;
 237         }
 238         return hc;
 239 }
 240
 241 static int
 242 eqstring(const char *s1, const char *s2)
 243 {
 244         while (*s1 && *s2) {
 245                 int x1, x2;
 246
 247                 x1 = *(const unsigned char *)s1;
 248                 x2 = *(const unsigned char *)s2;
 249                 if (x1 >= 'A' && x1 <= 'Z') {
 250                         x1 += 'a' - 'A';
 251                 }
 252                 if (x2 >= 'A' && x2 <= 'Z') {
 253                         x2 += 'a' - 'A';
 254                 }
 255                 if (x1 != x2) {
 256                         return 0;
 257                 }
 258                 s1 ++;
 259                 s2 ++;
 260         }
 261         return !(*s1 || *s2);
 262 }
 263
 264 static void
 265 HT_expand(HT *ht)
 266 {
 267         size_t n, n2, u;
 268         ht_elt **new_buckets;
 269
 270         n = ht->num_buckets;
 271         n2 = n << 1;
 272         new_buckets = xmalloc(n2 * sizeof *new_buckets);
 273         for (u = 0; u < n2; u ++) {
 274                 new_buckets[u] = NULL;
 275         }
 276         for (u = 0; u < n; u ++) {
 277                 ht_elt *e, *f;
 278
 279                 f = NULL;
 280                 for (e = ht->buckets[u]; e != NULL; e = f) {
 281                         uint32_t hc;
 282                         size_t v;
 283
 284                         hc = hash_string(e->name);
 285                         v = (size_t)(hc & ((uint32_t)n2 - 1));
 286                         f = e->next;
 287                         e->next = new_buckets[v];
 288                         new_buckets[v] = e;
 289                 }
 290         }
 291         xfree(ht->buckets);
 292         ht->buckets = new_buckets;
 293         ht->num_buckets = n2;
 294 }
 295
 296 static void *
 297 HT_put(HT *ht, const char *name, void *value)
 298 {
 299         uint32_t hc;
 300         size_t k;
 301         ht_elt *e, **prev;
 302
 303         hc = hash_string(name);
 304         k = (size_t)(hc & ((uint32_t)ht->num_buckets - 1));
 305         prev = &ht->buckets[k];
 306         e = *prev;
 307         while (e != NULL) {
 308                 if (eqstring(name, e->name)) {
 309                         void *old_value;
 310
 311                         old_value = e->value;
 312                         if (value == NULL) {
 313                                 *prev = e->next;
 314                                 xfree(e->name);
 315                                 xfree(e);
 316                                 ht->size --;
 317                         } else {
 318                                 e->value = value;
 319                         }
 320                         return old_value;
 321                 }
 322                 prev = &e->next;
 323                 e = *prev;
 324         }
 325         if (value != NULL) {
 326                 e = xmalloc(sizeof *e);
 327                 e->name = xstrdup(name);
 328                 e->value = value;
 329                 e->next = ht->buckets[k];
 330                 ht->buckets[k] = e;
 331                 ht->size ++;
 332                 if (ht->size > ht->num_buckets) {
 333                         HT_expand(ht);
 334                 }
 335         }
 336         return NULL;
 337 }
 338
 339 /* unused
 340 static void *
 341 HT_remove(HT *ht, const char *name)
 342 {
 343         return HT_put(ht, name, NULL);
 344 }
 345 */
 346
 347 static void *
 348 HT_get(const HT *ht, const char *name)
 349 {
 350         uint32_t hc;
 351         size_t k;
 352         ht_elt *e;
 353
 354         hc = hash_string(name);
 355         k = (size_t)(hc & ((uint32_t)ht->num_buckets - 1));
 356         for (e = ht->buckets[k]; e != NULL; e = e->next) {
 357                 if (eqstring(name, e->name)) {
 358                         return e->value;
 359                 }
 360         }
 361         return NULL;
 362 }
 363
 364 static void
 365 HT_clear(HT *ht, void (*free_value)(void *value))
 366 {
 367         size_t u;
 368
 369         for (u = 0; u < ht->num_buckets; u ++) {
 370                 ht_elt *e, *f;
 371
 372                 f = NULL;
 373                 for (e = ht->buckets[u]; e != NULL; e = f) {
 374                         f = e->next;
 375                         xfree(e->name);
 376                         if (free_value != 0) {
 377                                 free_value(e->value);
 378                         }
 379                         xfree(e);
 380                 }
 381                 ht->buckets[u] = NULL;
 382         }
 383         ht->size = 0;
 384 }
 385
 386 static void
 387 HT_free(HT *ht, void (*free_value)(void *value))
 388 {
 389         HT_clear(ht, free_value);
 390         xfree(ht->buckets);
 391         xfree(ht);
 392 }
 393
 394 /* unused
 395 static size_t
 396 HT_size(HT *ht)
 397 {
 398         return ht->size;
 399 }
 400 */
 401
 402 static unsigned char *
 403 read_all(FILE *f, size_t *len)
 404 {
 405         unsigned char *buf;
 406         size_t ptr, blen;
 407
 408         blen = 1024;
 409         buf = xmalloc(blen);
 410         ptr = 0;
 411         for (;;) {
 412                 size_t rlen;
 413
 414                 if (ptr == blen) {
 415                         unsigned char *buf2;
 416
 417                         blen <<= 1;
 418                         buf2 = xmalloc(blen);
 419                         memcpy(buf2, buf, ptr);
 420                         xfree(buf);
 421                         buf = buf2;
 422                 }
 423                 rlen = fread(buf + ptr, 1, blen - ptr, f);
 424                 if (rlen == 0) {
 425                         unsigned char *buf3;
 426
 427                         buf3 = xmalloc(ptr);
 428                         memcpy(buf3, buf, ptr);
 429                         xfree(buf);
 430                         *len = ptr;
 431                         return buf3;
 432                 }
 433                 ptr += rlen;
 434         }
 435 }
 436
 437 static unsigned char *
 438 read_file(const char *name, size_t *len)
 439 {
 440         FILE *f;
 441         unsigned char *buf;
 442
 443 #ifdef DIRNAME
 444         char *dname;
 445
 446         dname = xmalloc(strlen(DIRNAME) + strlen(name) + 2);
 447         sprintf(dname, "%s/%s", DIRNAME, name);
 448         name = dname;
 449 #endif
 450         f = fopen(name, "rb");
 451         if (f == NULL) {
 452                 fprintf(stderr, "could not open file '%s'\n", name);
 453                 exit(EXIT_FAILURE);
 454         }
 455         buf = read_all(f, len);
 456         if (ferror(f)) {
 457                 fprintf(stderr, "read error on file '%s'\n", name);
 458                 exit(EXIT_FAILURE);
 459         }
 460         fclose(f);
 461 #ifdef DIRNAME
 462         xfree(dname);
 463 #endif
 464         return buf;
 465 }
 466
 467 static int
 468 parse_dec(const char *s, unsigned len, int *val)
 469 {
 470         int acc;
 471
 472         acc = 0;
 473         while (len -- > 0) {
 474                 int c;
 475
 476                 c = *s ++;
 477                 if (c >= '0' && c <= '9') {
 478                         acc = (acc * 10) + (c - '0');
 479                 } else {
 480                         return -1;
 481                 }
 482         }
 483         *val = acc;
 484         return 0;
 485 }
 486
 487 static int
 488 parse_choice(const char *s, const char *acceptable)
 489 {
 490         int c;
 491
 492         c = *s;
 493         while (*acceptable) {
 494                 if (c == *acceptable ++) {
 495                         return 0;
 496                 }
 497         }
 498         return -1;
 499 }
 500
 501 static int
 502 month_length(int year, int month)
 503 {
 504         static const int base_month_length[] = {
 505                 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
 506         };
 507
 508         int x;
 509
 510         x = base_month_length[month - 1];
 511         if (month == 2 && year % 4 == 0
 512                 && (year % 100 != 0 || year % 400 == 0))
 513         {
 514                 x ++;
 515         }
 516         return x;
 517 }
 518
 519 /*
 520  * Convert a time string to a days+seconds count. Returned value is 0
 521  * on success, -1 on error.
 522  */
 523 static int
 524 string_to_time(const char *s, uint32_t *days, uint32_t *seconds)
 525 {
 526         int year, month, day, hour, minute, second;
 527         int day_of_year, leaps, i;
 528
 529         if (parse_dec(s, 4, &year) < 0) {
 530                 return -1;
 531         }
 532         s += 4;
 533         if (parse_choice(s ++, "-:/ ") < 0) {
 534                 return -1;
 535         }
 536         if (parse_dec(s, 2, &month) < 0) {
 537                 return -1;
 538         }
 539         s += 2;
 540         if (parse_choice(s ++, "-:/ ") < 0) {
 541                 return -1;
 542         }
 543         if (parse_dec(s, 2, &day) < 0) {
 544                 return -1;
 545         }
 546         s += 2;
 547         if (parse_choice(s ++, " T") < 0) {
 548                 return -1;
 549         }
 550         if (parse_dec(s, 2, &hour) < 0) {
 551                 return -1;
 552         }
 553         s += 2;
 554         if (parse_choice(s ++, "-:/ ") < 0) {
 555                 return -1;
 556         }
 557         if (parse_dec(s, 2, &minute) < 0) {
 558                 return -1;
 559         }
 560         s += 2;
 561         if (parse_choice(s ++, "-:/ ") < 0) {
 562                 return -1;
 563         }
 564         if (parse_dec(s, 2, &second) < 0) {
 565                 return -1;
 566         }
 567         s += 2;
 568         if (*s == '.') {
 569                 while (*s && *s >= '0' && *s <= '9') {
 570                         s ++;
 571                 }
 572         }
 573         if (*s) {
 574                 if (*s ++ != 'Z') {
 575                         return -1;
 576                 }
 577                 if (*s) {
 578                         return -1;
 579                 }
 580         }
 581
 582         if (month < 1 || month > 12) {
 583                 return -1;
 584         }
 585         day_of_year = 0;
 586         for (i = 1; i < month; i ++) {
 587                 day_of_year += month_length(year, i);
 588         }
 589         if (day < 1 || day > month_length(year, month)) {
 590                 return -1;
 591         }
 592         day_of_year += (day - 1);
 593         leaps = (year + 3) / 4 - (year + 99) / 100 + (year + 399) / 400;
 594
 595         if (hour > 23 || minute > 59 || second > 60) {
 596                 return -1;
 597         }
 598         *days = (uint32_t)year * 365 + (uint32_t)leaps + day_of_year;
 599         *seconds = (uint32_t)hour * 3600 + minute * 60 + second;
 600         return 0;
 601 }
 602
 603 static FILE *conf;
 604 static int conf_delayed_char;
 605 static long conf_linenum;
 606 static string_builder *line_builder;
 607 static long current_linenum;
 608
 609 static void
 610 conf_init(const char *fname)
 611 {
 612         conf = fopen(fname, "r");
 613         if (conf == NULL) {
 614                 fprintf(stderr, "could not open file '%s'\n", fname);
 615                 exit(EXIT_FAILURE);
 616         }
 617         conf_delayed_char = -1;
 618         conf_linenum = 1;
 619         line_builder = SB_new();
 620 }
 621
 622 static void
 623 conf_close(void)
 624 {
 625         if (conf != NULL) {
 626                 if (ferror(conf)) {
 627                         fprintf(stderr, "read error on configuration file\n");
 628                         exit(EXIT_FAILURE);
 629                 }
 630                 fclose(conf);
 631                 conf = NULL;
 632         }
 633         if (line_builder != NULL) {
 634                 SB_free(line_builder);
 635                 line_builder = NULL;
 636         }
 637 }
 638
 639 /*
 640  * Get next character from the config file.
 641  */
 642 static int
 643 conf_next_low(void)
 644 {
 645         int x;
 646
 647         x = conf_delayed_char;
 648         if (x >= 0) {
 649                 conf_delayed_char = -1;
 650         } else {
 651                 x = fgetc(conf);
 652                 if (x == EOF) {
 653                         x = -1;
 654                 }
 655         }
 656         if (x == '\r') {
 657                 x = fgetc(conf);
 658                 if (x == EOF) {
 659                         x = -1;
 660                 }
 661                 if (x != '\n') {
 662                         conf_delayed_char = x;
 663                         x = '\n';
 664                 }
 665         }
 666         if (x == '\n') {
 667                 conf_linenum ++;
 668         }
 669         return x;
 670 }
 671
 672 static int
 673 is_ws(int x)
 674 {
 675         return x <= 32;
 676 }
 677
 678 static int
 679 is_name_char(int c)
 680 {
 681         return (c >= 'A' && c <= 'Z')
 682                 || (c >= 'a' && c <= 'z')
 683                 || (c >= '0' && c <= '9')
 684                 || (c == '_' || c == '-' || c == '.');
 685 }
 686
 687 /*
 688  * Read a complete line. This handles line continuation; empty lines and
 689  * comment lines are skipped; leading and trailing whitespace is removed.
 690  * Returned value is 0 (line read) or -1 (no line, EOF reached). The line
 691  * contents are accumulated in the line_builder.
 692  */
 693 static int
 694 conf_next_line(void)
 695 {
 696         for (;;) {
 697                 int c;
 698                 int lcwb;
 699
 700                 SB_reset(line_builder);
 701
 702                 /*
 703                  * Get first non-whitespace character. This skips empty
 704                  * lines. Comment lines (first non-whitespace character
 705                  * is a semicolon) are also skipped.
 706                  */
 707                 for (;;) {
 708                         c = conf_next_low();
 709                         if (c < 0) {
 710                                 return -1;
 711                         }
 712                         if (is_ws(c)) {
 713                                 continue;
 714                         }
 715                         if (c == ';') {
 716                                 for (;;) {
 717                                         c = conf_next_low();
 718                                         if (c < 0) {
 719                                                 return -1;
 720                                         }
 721                                         if (c == '\n') {
 722                                                 break;
 723                                         }
 724                                 }
 725                                 continue;
 726                         }
 727                         break;
 728                 }
 729
 730                 /*
 731                  * Read up the remaining of the line. The line continuation
 732                  * sequence (final backslash) is detected and processed.
 733                  */
 734                 current_linenum = conf_linenum;
 735                 lcwb = (c == '\\');
 736                 SB_append_char(line_builder, c);
 737                 for (;;) {
 738                         c = conf_next_low();
 739                         if (c < 0) {
 740                                 break;
 741                         }
 742                         if (lcwb) {
 743                                 if (c == '\n') {
 744                                         SB_set_length(line_builder,
 745                                                 SB_length(line_builder) - 1);
 746                                 }
 747                                 lcwb = 0;
 748                                 continue;
 749                         }
 750                         if (c == '\n') {
 751                                 break;
 752                         } else if (c == '\\') {
 753                                 lcwb = 1;
 754                         }
 755                         SB_append_char(line_builder, c);
 756                 }
 757
 758                 /*
 759                  * Remove trailing whitespace (if any).
 760                  */
 761                 for (;;) {
 762                         size_t u;
 763
 764                         u = SB_length(line_builder);
 765                         if (u == 0 || !is_ws(
 766                                 SB_contents(line_builder)[u - 1]))
 767                         {
 768                                 break;
 769                         }
 770                         SB_set_length(line_builder, u - 1);
 771                 }
 772
 773                 /*
 774                  * We might end up with a totally empty line (in case there
 775                  * was a line continuation but nothing else), in which case
 776                  * we must loop.
 777                  */
 778                 if (SB_length(line_builder) > 0) {
 779                         return 0;
 780                 }
 781         }
 782 }
 783
 784 /*
 785  * Test whether the current line is a section header. If yes, then the
 786  * header name is extracted, and returned as a newly allocated string.
 787  * Otherwise, NULL is returned.
 788  */
 789 static char *
 790 parse_header_name(void)
 791 {
 792         char *buf, *name;
 793         size_t u, v, w, len;
 794
 795         buf = SB_contents(line_builder);
 796         len = SB_length(line_builder);
 797         if (len < 2 || buf[0] != '[' || buf[len - 1] != ']') {
 798                 return NULL;
 799         }
 800         u = 1;
 801         v = len - 1;
 802         while (u < v && is_ws(buf[u])) {
 803                 u ++;
 804         }
 805         while (u < v && is_ws(buf[v - 1])) {
 806                 v --;
 807         }
 808         if (u == v) {
 809                 return NULL;
 810         }
 811         for (w = u; w < v; w ++) {
 812                 if (!is_name_char(buf[w])) {
 813                         return NULL;
 814                 }
 815         }
 816         len = v - u;
 817         name = xmalloc(len + 1);
 818         memcpy(name, buf + u, len);
 819         name[len] = 0;
 820         return name;
 821 }
 822
 823 /*
 824  * Parse the current line as a 'name = value' pair. The pair is pushed into
 825  * the provided hash table. On error (including a duplicate key name),
 826  * this function returns -1; otherwise, it returns 0.
 827  */
 828 static int
 829 parse_keyvalue(HT *d)
 830 {
 831         char *buf, *name, *value;
 832         size_t u, len;
 833
 834         buf = SB_contents(line_builder);
 835         len = SB_length(line_builder);
 836         for (u = 0; u < len; u ++) {
 837                 if (!is_name_char(buf[u])) {
 838                         break;
 839                 }
 840         }
 841         if (u == 0) {
 842                 return -1;
 843         }
 844         name = xmalloc(u + 1);
 845         memcpy(name, buf, u);
 846         name[u] = 0;
 847         if (HT_get(d, name) != NULL) {
 848                 xfree(name);
 849                 return -1;
 850         }
 851         while (u < len && is_ws(buf[u])) {
 852                 u ++;
 853         }
 854         if (u >= len || buf[u] != '=') {
 855                 xfree(name);
 856                 return -1;
 857         }
 858         u ++;
 859         while (u < len && is_ws(buf[u])) {
 860                 u ++;
 861         }
 862         value = xmalloc(len - u + 1);
 863         memcpy(value, buf + u, len - u);
 864         value[len - u] = 0;
 865         HT_put(d, name, value);
 866         xfree(name);
 867         return 0;
 868 }
 869
 870 /*
 871  * Public keys, indexed by name. Elements are pointers to br_x509_pkey
 872  * structures.
 873  */
 874 static HT *keys;
 875
 876 /*
 877  * Trust anchors, indexed by name. Elements are pointers to
 878  * test_trust_anchor structures.
 879  */
 880 static HT *trust_anchors;
 881
 882 typedef struct {
 883         unsigned char *dn;
 884         size_t dn_len;
 885         unsigned flags;
 886         char *key_name;
 887 } test_trust_anchor;
 888
 889 /*
 890  * Test case: trust anchors, certificates (file names), key type and
 891  * usage, expected status and EE public key.
 892  */
 893 typedef struct {
 894         char *name;
 895         char **ta_names;
 896         char **cert_names;
 897         char *servername;
 898         unsigned key_type_usage;
 899         unsigned status;
 900         char *ee_key_name;
 901         unsigned hashes;
 902         uint32_t days, seconds;
 903 } test_case;
 904
 905 static test_case *all_chains;
 906 static size_t all_chains_ptr, all_chains_len;
 907
 908 static void
 909 free_key(void *value)
 910 {
 911         br_x509_pkey *pk;
 912
 913         pk = value;
 914         switch (pk->key_type) {
 915         case BR_KEYTYPE_RSA:
 916                 xfree((void *)pk->key.rsa.n);
 917                 xfree((void *)pk->key.rsa.e);
 918                 break;
 919         case BR_KEYTYPE_EC:
 920                 xfree((void *)pk->key.ec.q);
 921                 break;
 922         default:
 923                 fprintf(stderr, "unknown key type: %d\n", pk->key_type);
 924                 exit(EXIT_FAILURE);
 925                 break;
 926         }
 927         xfree(pk);
 928 }
 929
 930 static void
 931 free_trust_anchor(void *value)
 932 {
 933         test_trust_anchor *ttc;
 934
 935         ttc = value;
 936         xfree(ttc->dn);
 937         xfree(ttc->key_name);
 938         xfree(ttc);
 939 }
 940
 941 static void
 942 free_test_case_contents(test_case *tc)
 943 {
 944         size_t u;
 945
 946         xfree(tc->name);
 947         for (u = 0; tc->ta_names[u]; u ++) {
 948                 xfree(tc->ta_names[u]);
 949         }
 950         xfree(tc->ta_names);
 951         for (u = 0; tc->cert_names[u]; u ++) {
 952                 xfree(tc->cert_names[u]);
 953         }
 954         xfree(tc->cert_names);
 955         xfree(tc->servername);
 956         xfree(tc->ee_key_name);
 957 }
 958
 959 static char *
 960 get_value(char *objtype, HT *objdata, long linenum, char *name)
 961 {
 962         char *value;
 963
 964         value = HT_get(objdata, name);
 965         if (value == NULL) {
 966                 fprintf(stderr,
 967                         "missing property '%s' in section '%s' (line %ld)\n",
 968                         name, objtype, linenum);
 969                 exit(EXIT_FAILURE);
 970         }
 971         return value;
 972 }
 973
 974 static unsigned char *
 975 parse_hex(const char *name, long linenum, const char *value, size_t *len)
 976 {
 977         unsigned char *buf;
 978
 979         buf = NULL;
 980         for (;;) {
 981                 size_t u, ptr;
 982                 int acc, z;
 983
 984                 ptr = 0;
 985                 acc = 0;
 986                 z = 0;
 987                 for (u = 0; value[u]; u ++) {
 988                         int c;
 989
 990                         c = value[u];
 991                         if (c >= '0' && c <= '9') {
 992                                 c -= '0';
 993                         } else if (c >= 'A' && c <= 'F') {
 994                                 c -= 'A' - 10;
 995                         } else if (c >= 'a' && c <= 'f') {
 996                                 c -= 'a' - 10;
 997                         } else if (c == ' ' || c == ':') {
 998                                 continue;
 999                         } else {
1000                                 fprintf(stderr, "invalid hexadecimal character"
1001                                         " in '%s' (line %ld)\n",
1002                                         name, linenum);
1003                                 exit(EXIT_FAILURE);
1004                         }
1005                         if (z) {
1006                                 if (buf != NULL) {
1007                                         buf[ptr] = (acc << 4) + c;
1008                                 }
1009                                 ptr ++;
1010                         } else {
1011                                 acc = c;
1012                         }
1013                         z = !z;
1014                 }
1015                 if (z) {
1016                         fprintf(stderr, "invalid hexadecimal value (partial"
1017                                 " byte) in '%s' (line %ld)\n",
1018                                 name, linenum);
1019                         exit(EXIT_FAILURE);
1020                 }
1021                 if (buf == NULL) {
1022                         buf = xmalloc(ptr);
1023                 } else {
1024                         *len = ptr;
1025                         return buf;
1026                 }
1027         }
1028 }
1029
1030 static char **
1031 split_names(const char *value)
1032 {
1033         char **names;
1034         size_t len;
1035
1036         names = NULL;
1037         len = strlen(value);
1038         for (;;) {
1039                 size_t u, ptr;
1040
1041                 ptr = 0;
1042                 u = 0;
1043                 while (u < len) {
1044                         size_t v;
1045
1046                         while (u < len && is_ws(value[u])) {
1047                                 u ++;
1048                         }
1049                         v = u;
1050                         while (v < len && !is_ws(value[v])) {
1051                                 v ++;
1052                         }
1053                         if (v > u) {
1054                                 if (names != NULL) {
1055                                         char *name;
1056
1057                                         name = xmalloc(v - u + 1);
1058                                         memcpy(name, value + u, v - u);
1059                                         name[v - u] = 0;
1060                                         names[ptr] = name;
1061                                 }
1062                                 ptr ++;
1063                         }
1064                         u = v;
1065                 }
1066                 if (names == NULL) {
1067                         names = xmalloc((ptr + 1) * sizeof *names);
1068                 } else {
1069                         names[ptr] = NULL;
1070                         return names;
1071                 }
1072         }
1073 }
1074
1075 static int
1076 string_to_hash(const char *name)
1077 {
1078         char tmp[20];
1079         size_t u, v;
1080
1081         for (u = 0, v = 0; name[u]; u ++) {
1082                 int c;
1083
1084                 c = name[u];
1085                 if ((c >= '0' && c <= '9')
1086                         || (c >= 'A' && c <= 'Z')
1087                         || (c >= 'a' && c <= 'z'))
1088                 {
1089                         tmp[v ++] = c;
1090                         if (v == sizeof tmp) {
1091                                 return -1;
1092                         }
1093                 }
1094         }
1095         tmp[v] = 0;
1096         if (eqstring(tmp, "md5")) {
1097                 return br_md5_ID;
1098         } else if (eqstring(tmp, "sha1")) {
1099                 return br_sha1_ID;
1100         } else if (eqstring(tmp, "sha224")) {
1101                 return br_sha224_ID;
1102         } else if (eqstring(tmp, "sha256")) {
1103                 return br_sha256_ID;
1104         } else if (eqstring(tmp, "sha384")) {
1105                 return br_sha384_ID;
1106         } else if (eqstring(tmp, "sha512")) {
1107                 return br_sha512_ID;
1108         } else {
1109                 return -1;
1110         }
1111 }
1112
1113 static int
1114 string_to_curve(const char *name)
1115 {
1116         char tmp[20];
1117         size_t u, v;
1118
1119         for (u = 0, v = 0; name[u]; u ++) {
1120                 int c;
1121
1122                 c = name[u];
1123                 if ((c >= '0' && c <= '9')
1124                         || (c >= 'A' && c <= 'Z')
1125                         || (c >= 'a' && c <= 'z'))
1126                 {
1127                         tmp[v ++] = c;
1128                         if (v == sizeof tmp) {
1129                                 return -1;
1130                         }
1131                 }
1132         }
1133         tmp[v] = 0;
1134         if (eqstring(tmp, "p256") || eqstring(tmp, "secp256r1")) {
1135                 return BR_EC_secp256r1;
1136         } else if (eqstring(tmp, "p384") || eqstring(tmp, "secp384r1")) {
1137                 return BR_EC_secp384r1;
1138         } else if (eqstring(tmp, "p521") || eqstring(tmp, "secp521r1")) {
1139                 return BR_EC_secp521r1;
1140         } else {
1141                 return -1;
1142         }
1143 }
1144
1145 static void
1146 parse_object(char *objtype, HT *objdata, long linenum)
1147 {
1148         char *name;
1149
1150         name = get_value(objtype, objdata, linenum, "name");
1151         if (eqstring(objtype, "key")) {
1152                 char *stype;
1153                 br_x509_pkey *pk;
1154
1155                 stype = get_value(objtype, objdata, linenum, "type");
1156                 pk = xmalloc(sizeof *pk);
1157                 if (eqstring(stype, "RSA")) {
1158                         char *sn, *se;
1159
1160                         sn = get_value(objtype, objdata, linenum, "n");
1161                         se = get_value(objtype, objdata, linenum, "e");
1162                         pk->key_type = BR_KEYTYPE_RSA;
1163                         pk->key.rsa.n = parse_hex("modulus", linenum,
1164                                 sn, &pk->key.rsa.nlen);
1165                         pk->key.rsa.e = parse_hex("exponent", linenum,
1166                                 se, &pk->key.rsa.elen);
1167                 } else if (eqstring(stype, "EC")) {
1168                         char *sc, *sq;
1169                         int curve;
1170
1171                         sc = get_value(objtype, objdata, linenum, "curve");
1172                         sq = get_value(objtype, objdata, linenum, "q");
1173                         curve = string_to_curve(sc);
1174                         if (curve < 0) {
1175                                 fprintf(stderr, "unknown curve name: '%s'"
1176                                         " (line %ld)\n", sc, linenum);
1177                                 exit(EXIT_FAILURE);
1178                         }
1179                         pk->key_type = BR_KEYTYPE_EC;
1180                         pk->key.ec.curve = curve;
1181                         pk->key.ec.q = parse_hex("public point", linenum,
1182                                 sq, &pk->key.ec.qlen);
1183                 } else {
1184                         fprintf(stderr, "unknown key type '%s' (line %ld)\n",
1185                                 stype, linenum);
1186                         exit(EXIT_FAILURE);
1187                 }
1188                 if (HT_put(keys, name, pk) != NULL) {
1189                         fprintf(stderr, "duplicate key: '%s' (line %ld)\n",
1190                                 name, linenum);
1191                         exit(EXIT_FAILURE);
1192                 }
1193         } else if (eqstring(objtype, "anchor")) {
1194                 char *dnfile, *kname, *tatype;
1195                 test_trust_anchor *tta;
1196
1197                 dnfile = get_value(objtype, objdata, linenum, "DN_file");
1198                 kname = get_value(objtype, objdata, linenum, "key");
1199                 tatype = get_value(objtype, objdata, linenum, "type");
1200                 tta = xmalloc(sizeof *tta);
1201                 tta->dn = read_file(dnfile, &tta->dn_len);
1202                 tta->key_name = xstrdup(kname);
1203                 if (eqstring(tatype, "CA")) {
1204                         tta->flags = BR_X509_TA_CA;
1205                 } else if (eqstring(tatype, "EE")) {
1206                         tta->flags = 0;
1207                 } else {
1208                         fprintf(stderr,
1209                                 "unknown trust anchor type: '%s' (line %ld)\n",
1210                                 tatype, linenum);
1211                 }
1212                 if (HT_put(trust_anchors, name, tta) != NULL) {
1213                         fprintf(stderr,
1214                                 "duplicate trust anchor: '%s' (line %ld)\n",
1215                                 name, linenum);
1216                         exit(EXIT_FAILURE);
1217                 }
1218         } else if (eqstring(objtype, "chain")) {
1219                 test_case tc;
1220                 char *ktype, *kusage, *sstatus, *shashes, *stime;
1221
1222                 ktype = get_value(objtype, objdata, linenum, "keytype");
1223                 kusage = get_value(objtype, objdata, linenum, "keyusage");
1224                 sstatus = get_value(objtype, objdata, linenum, "status");
1225                 tc.name = xstrdup(name);
1226                 tc.ta_names = split_names(
1227                         get_value(objtype, objdata, linenum, "anchors"));
1228                 tc.cert_names = split_names(
1229                         get_value(objtype, objdata, linenum, "chain"));
1230                 tc.servername = xstrdup(HT_get(objdata, "servername"));
1231                 if (eqstring(ktype, "RSA")) {
1232                         tc.key_type_usage = BR_KEYTYPE_RSA;
1233                 } else if (eqstring(ktype, "EC")) {
1234                         tc.key_type_usage = BR_KEYTYPE_EC;
1235                 } else {
1236                         fprintf(stderr,
1237                                 "unknown key type: '%s' (line %ld)\n",
1238                                 ktype, linenum);
1239                         exit(EXIT_FAILURE);
1240                 }
1241                 if (eqstring(kusage, "KEYX")) {
1242                         tc.key_type_usage |= BR_KEYTYPE_KEYX;
1243                 } else if (eqstring(kusage, "SIGN")) {
1244                         tc.key_type_usage |= BR_KEYTYPE_SIGN;
1245                 } else {
1246                         fprintf(stderr,
1247                                 "unknown key usage: '%s' (line %ld)\n",
1248                                 kusage, linenum);
1249                         exit(EXIT_FAILURE);
1250                 }
1251                 tc.status = (unsigned)atoi(sstatus);
1252                 if (tc.status == 0) {
1253                         tc.ee_key_name = xstrdup(
1254                                 get_value(objtype, objdata, linenum, "eekey"));
1255                 } else {
1256                         tc.ee_key_name = NULL;
1257                 }
1258                 shashes = HT_get(objdata, "hashes");
1259                 if (shashes == NULL) {
1260                         tc.hashes = (unsigned)-1;
1261                 } else {
1262                         char **hns;
1263                         size_t u;
1264
1265                         tc.hashes = 0;
1266                         hns = split_names(shashes);
1267                         for (u = 0;; u ++) {
1268                                 char *hn;
1269                                 int id;
1270
1271                                 hn = hns[u];
1272                                 if (hn == NULL) {
1273                                         break;
1274                                 }
1275                                 id = string_to_hash(hn);
1276                                 if (id < 0) {
1277                                         fprintf(stderr,
1278                                                 "unknown hash function '%s'"
1279                                                 " (line %ld)\n", hn, linenum);
1280                                         exit(EXIT_FAILURE);
1281                                 }
1282                                 tc.hashes |= (unsigned)1 << id;
1283                                 xfree(hn);
1284                         }
1285                         xfree(hns);
1286                 }
1287                 stime = HT_get(objdata, "time");
1288                 if (stime == NULL) {
1289                         stime = DEFAULT_TIME;
1290                 }
1291                 if (string_to_time(stime, &tc.days, &tc.seconds) < 0) {
1292                         fprintf(stderr, "invalid time string '%s' (line %ld)\n",
1293                                 stime, linenum);
1294                         exit(EXIT_FAILURE);
1295                 }
1296                 if (all_chains_ptr == all_chains_len) {
1297                         if (all_chains_len == 0) {
1298                                 all_chains_len = 8;
1299                                 all_chains = xmalloc(
1300                                         all_chains_len * sizeof *all_chains);
1301                         } else {
1302                                 test_case *ntc;
1303                                 size_t nlen;
1304
1305                                 nlen = all_chains_len << 1;
1306                                 ntc = xmalloc(nlen * sizeof *ntc);
1307                                 memcpy(ntc, all_chains,
1308                                         all_chains_len * sizeof *all_chains);
1309                                 xfree(all_chains);
1310                                 all_chains = ntc;
1311                                 all_chains_len = nlen;
1312                         }
1313                 }
1314                 all_chains[all_chains_ptr ++] = tc;
1315         } else {
1316                 fprintf(stderr, "unknown section type '%s' (line %ld)\n",
1317                         objtype, linenum);
1318                 exit(EXIT_FAILURE);
1319         }
1320 }
1321
1322 static void
1323 process_conf_file(const char *fname)
1324 {
1325         char *objtype;
1326         HT *objdata;
1327         long objlinenum;
1328
1329         keys = HT_new();
1330         trust_anchors = HT_new();
1331         all_chains = NULL;
1332         all_chains_ptr = 0;
1333         all_chains_len = 0;
1334         conf_init(fname);
1335         objtype = NULL;
1336         objdata = HT_new();
1337         objlinenum = 0;
1338         for (;;) {
1339                 char *hname;
1340
1341                 if (conf_next_line() < 0) {
1342                         break;
1343                 }
1344                 hname = parse_header_name();
1345                 if (hname != NULL) {
1346                         if (objtype != NULL) {
1347                                 parse_object(objtype, objdata, objlinenum);
1348                                 HT_clear(objdata, xfree);
1349                                 xfree(objtype);
1350                         }
1351                         objtype = hname;
1352                         objlinenum = current_linenum;
1353                         continue;
1354                 }
1355                 if (objtype == NULL) {
1356                         fprintf(stderr, "no current section (line %ld)\n",
1357                                 current_linenum);
1358                         exit(EXIT_FAILURE);
1359                 }
1360                 if (parse_keyvalue(objdata) < 0) {
1361                         fprintf(stderr, "wrong configuration, line %ld\n",
1362                                 current_linenum);
1363                         exit(EXIT_FAILURE);
1364                 }
1365         }
1366         if (objtype != NULL) {
1367                 parse_object(objtype, objdata, objlinenum);
1368                 xfree(objtype);
1369         }
1370         HT_free(objdata, xfree);
1371         conf_close();
1372 }
1373
1374 static const struct {
1375         int id;
1376         const br_hash_class *impl;
1377 } hash_impls[] = {
1378         { br_md5_ID, &br_md5_vtable },
1379         { br_sha1_ID, &br_sha1_vtable },
1380         { br_sha224_ID, &br_sha224_vtable },
1381         { br_sha256_ID, &br_sha256_vtable },
1382         { br_sha384_ID, &br_sha384_vtable },
1383         { br_sha512_ID, &br_sha512_vtable },
1384         { 0, NULL }
1385 };
1386
1387 typedef struct {
1388         unsigned char *data;
1389         size_t len;
1390 } blob;
1391
1392 static int
1393 eqbigint(const unsigned char *b1, size_t b1_len,
1394         const unsigned char *b2, size_t b2_len)
1395 {
1396         while (b1_len > 0 && *b1 == 0) {
1397                 b1 ++;
1398                 b1_len --;
1399         }
1400         while (b2_len > 0 && *b2 == 0) {
1401                 b2 ++;
1402                 b2_len --;
1403         }
1404         return b1_len == b2_len && memcmp(b1, b2, b1_len) == 0;
1405 }
1406
1407 static int
1408 eqpkey(const br_x509_pkey *pk1, const br_x509_pkey *pk2)
1409 {
1410         if (pk1 == pk2) {
1411                 return 1;
1412         }
1413         if (pk1 == NULL || pk2 == NULL) {
1414                 return 0;
1415         }
1416         if (pk1->key_type != pk2->key_type) {
1417                 return 0;
1418         }
1419         switch (pk1->key_type) {
1420         case BR_KEYTYPE_RSA:
1421                 return eqbigint(pk1->key.rsa.n, pk1->key.rsa.nlen,
1422                         pk2->key.rsa.n, pk2->key.rsa.nlen)
1423                         && eqbigint(pk1->key.rsa.e, pk1->key.rsa.elen,
1424                         pk2->key.rsa.e, pk2->key.rsa.elen);
1425         case BR_KEYTYPE_EC:
1426                 return pk1->key.ec.curve == pk2->key.ec.curve
1427                         && pk1->key.ec.qlen == pk2->key.ec.qlen
1428                         && memcmp(pk1->key.ec.q,
1429                                 pk2->key.ec.q, pk1->key.ec.qlen) == 0;
1430         default:
1431                 fprintf(stderr, "unknown key type: %d\n", pk1->key_type);
1432                 exit(EXIT_FAILURE);
1433                 break;
1434         }
1435         return 0;
1436 }
1437
1438 static size_t max_dp_usage;
1439 static size_t max_rp_usage;
1440
1441 static int
1442 check_time(void *ctx, uint32_t nbd, uint32_t nbs, uint32_t nad, uint32_t nas)
1443 {
1444         test_case *tc;
1445
1446         tc = ctx;
1447         if (tc->days < nbd || (tc->days == nbd && tc->seconds < nbs)) {
1448                 return -1;
1449         }
1450         if (tc->days > nad || (tc->days == nad && tc->seconds > nas)) {
1451                 return 1;
1452         }
1453         return 0;
1454 }
1455
1456 static void
1457 run_test_case(test_case *tc)
1458 {
1459         br_x509_minimal_context ctx;
1460         br_x509_trust_anchor *anchors;
1461         size_t num_anchors;
1462         size_t u;
1463         const br_hash_class *dnhash;
1464         size_t num_certs;
1465         blob *certs;
1466         br_x509_pkey *ee_pkey_ref;
1467         const br_x509_pkey *ee_pkey;
1468         unsigned usages;
1469         unsigned status;
1470         int j;
1471
1472         printf("%s: ", tc->name);
1473         fflush(stdout);
1474
1475         /*
1476          * Get the hash function to use for hashing DN. We can use just
1477          * any supported hash function, but for the elegance of things,
1478          * we will use one of the hash function implementations
1479          * supported for this test case (with SHA-1 as fallback).
1480          */
1481         dnhash = &br_sha1_vtable;
1482         for (u = 0; hash_impls[u].id; u ++) {
1483                 if ((tc->hashes & ((unsigned)1 << (hash_impls[u].id))) != 0) {
1484                         dnhash = hash_impls[u].impl;
1485                 }
1486         }
1487
1488         /*
1489          * Get trust anchors.
1490          */
1491         for (num_anchors = 0; tc->ta_names[num_anchors]; num_anchors ++);
1492         anchors = xmalloc(num_anchors * sizeof *anchors);
1493         for (u = 0; tc->ta_names[u]; u ++) {
1494                 test_trust_anchor *tta;
1495                 br_x509_pkey *tak;
1496
1497                 tta = HT_get(trust_anchors, tc->ta_names[u]);
1498                 if (tta == NULL) {
1499                         fprintf(stderr, "no such trust anchor: '%s'\n",
1500                                 tc->ta_names[u]);
1501                         exit(EXIT_FAILURE);
1502                 }
1503                 tak = HT_get(keys, tta->key_name);
1504                 if (tak == NULL) {
1505                         fprintf(stderr, "no such public key: '%s'\n",
1506                                 tta->key_name);
1507                         exit(EXIT_FAILURE);
1508                 }
1509                 anchors[u].dn.data = tta->dn;
1510                 anchors[u].dn.len = tta->dn_len;
1511                 anchors[u].flags = tta->flags;
1512                 anchors[u].pkey = *tak;
1513         }
1514
1515         /*
1516          * Read all relevant certificates.
1517          */
1518         for (num_certs = 0; tc->cert_names[num_certs]; num_certs ++);
1519         certs = xmalloc(num_certs * sizeof *certs);
1520         for (u = 0; u < num_certs; u ++) {
1521                 certs[u].data = read_file(tc->cert_names[u], &certs[u].len);
1522         }
1523
1524         /*
1525          * Get expected EE public key (if any).
1526          */
1527         if (tc->ee_key_name == NULL) {
1528                 ee_pkey_ref = NULL;
1529         } else {
1530                 ee_pkey_ref = HT_get(keys, tc->ee_key_name);
1531                 if (ee_pkey_ref == NULL) {
1532                         fprintf(stderr, "no such public key: '%s'\n",
1533                                 tc->ee_key_name);
1534                         exit(EXIT_FAILURE);
1535                 }
1536         }
1537
1538         /*
1539          * We do the test twice, to exercise distinct API functions.
1540          */
1541         for (j = 0; j < 2; j ++) {
1542                 /*
1543                  * Initialise the engine.
1544                  */
1545                 br_x509_minimal_init(&ctx, dnhash, anchors, num_anchors);
1546                 for (u = 0; hash_impls[u].id; u ++) {
1547                         int id;
1548
1549                         id = hash_impls[u].id;
1550                         if ((tc->hashes & ((unsigned)1 << id)) != 0) {
1551                                 br_x509_minimal_set_hash(&ctx,
1552                                         id, hash_impls[u].impl);
1553                         }
1554                 }
1555                 br_x509_minimal_set_rsa(&ctx, br_rsa_pkcs1_vrfy_get_default());
1556                 br_x509_minimal_set_ecdsa(&ctx,
1557                         br_ec_get_default(), br_ecdsa_vrfy_asn1_get_default());
1558
1559                 /*
1560                  * Set the validation date.
1561                  */
1562                 if (j == 0) {
1563                         br_x509_minimal_set_time(&ctx, tc->days, tc->seconds);
1564                 } else {
1565                         br_x509_minimal_set_time_callback(&ctx,
1566                                 tc, &check_time);
1567                 }
1568
1569                 /*
1570                  * Put "canaries" to detect actual stack usage.
1571                  */
1572                 for (u = 0; u < (sizeof ctx.dp_stack) / sizeof(uint32_t);
1573                         u ++)
1574                 {
1575                         ctx.dp_stack[u] = 0xA7C083FE;
1576                 }
1577                 for (u = 0; u < (sizeof ctx.rp_stack) / sizeof(uint32_t);
1578                         u ++)
1579                 {
1580                         ctx.rp_stack[u] = 0xA7C083FE;
1581                 }
1582
1583                 /*
1584                  * Run the engine. We inject certificates by chunks of 100
1585                  * bytes in order to exercise the coroutine API.
1586                  */
1587                 ctx.vtable->start_chain(&ctx.vtable, tc->servername);
1588                 for (u = 0; u < num_certs; u ++) {
1589                         size_t v;
1590
1591                         ctx.vtable->start_cert(&ctx.vtable, certs[u].len);
1592                         v = 0;
1593                         while (v < certs[u].len) {
1594                                 size_t w;
1595
1596                                 w = certs[u].len - v;
1597                                 if (w > 100) {
1598                                         w = 100;
1599                                 }
1600                                 ctx.vtable->append(&ctx.vtable,
1601                                         certs[u].data + v, w);
1602                                 v += w;
1603                         }
1604                         ctx.vtable->end_cert(&ctx.vtable);
1605                 }
1606                 status = ctx.vtable->end_chain(&ctx.vtable);
1607                 ee_pkey = ctx.vtable->get_pkey(&ctx.vtable, &usages);
1608
1609                 /*
1610                  * Check key type and usage.
1611                  */
1612                 if (ee_pkey != NULL) {
1613                         unsigned ktu;
1614
1615                         ktu = ee_pkey->key_type | usages;
1616                         if (tc->key_type_usage != (ktu & tc->key_type_usage)) {
1617                                 fprintf(stderr, "wrong key type + usage"
1618                                         " (expected 0x%02X, got 0x%02X)\n",
1619                                         tc->key_type_usage, ktu);
1620                                 exit(EXIT_FAILURE);
1621                         }
1622                 }
1623
1624                 /*
1625                  * Check results. Note that we may still get a public key if
1626                  * the path is "not trusted" (but otherwise fine).
1627                  */
1628                 if (status != tc->status) {
1629                         fprintf(stderr, "wrong status (got %d, expected %d)\n",
1630                                 status, tc->status);
1631                         exit(EXIT_FAILURE);
1632                 }
1633                 if (status == BR_ERR_X509_NOT_TRUSTED) {
1634                         ee_pkey = NULL;
1635                 }
1636                 if (!eqpkey(ee_pkey, ee_pkey_ref)) {
1637                         fprintf(stderr, "wrong EE public key\n");
1638                         exit(EXIT_FAILURE);
1639                 }
1640
1641                 /*
1642                  * Check stack usage.
1643                  */
1644                 for (u = (sizeof ctx.dp_stack) / sizeof(uint32_t);
1645                         u > 0; u --)
1646                 {
1647                         if (ctx.dp_stack[u - 1] != 0xA7C083FE) {
1648                                 if (max_dp_usage < u) {
1649                                         max_dp_usage = u;
1650                                 }
1651                                 break;
1652                         }
1653                 }
1654                 for (u = (sizeof ctx.rp_stack) / sizeof(uint32_t);
1655                         u > 0; u --)
1656                 {
1657                         if (ctx.rp_stack[u - 1] != 0xA7C083FE) {
1658                                 if (max_rp_usage < u) {
1659                                         max_rp_usage = u;
1660                                 }
1661                                 break;
1662                         }
1663                 }
1664         }
1665
1666         /*
1667          * Release everything.
1668          */
1669         for (u = 0; u < num_certs; u ++) {
1670                 xfree(certs[u].data);
1671         }
1672         xfree(certs);
1673         xfree(anchors);
1674         printf("OK\n");
1675 }
1676
1677 /*
1678  * A custom structure for tests, synchronised with the test certificate
1679  * names.crt.
1680  *
1681  * If num is 1 or more, then this is a DN element with OID '1.1.1.1.num'.
1682  * If num is -1 or less, then this is a SAN element of type -num.
1683  * If num is 0, then this is a SAN element of type OtherName with
1684  * OID 1.3.6.1.4.1.311.20.2.3 (Microsoft UPN).
1685  */
1686 typedef struct {
1687         int num;
1688         int status;
1689         const char *expected;
1690 } name_element_test;
1691
1692 static name_element_test names_ref[] = {
1693         /* === DN tests === */
1694         {
1695                 /* [12] 66:6f:6f */
1696                 1, 1, "foo"
1697         },
1698         {
1699                 /* [12] 62:61:72 */
1700                 1, 1, "bar"
1701         },
1702         {
1703                 /* [18] 31:32:33:34 */
1704                 2, 1, "1234"
1705         },
1706         {
1707                 /* [19] 66:6f:6f */
1708                 3, 1, "foo"
1709         },
1710         {
1711                 /* [20] 66:6f:6f */
1712                 4, 1, "foo"
1713         },
1714         {
1715                 /* [22] 66:6f:6f */
1716                 5, 1, "foo"
1717         },
1718         {
1719                 /* [30] 00:66:00:6f:00:6f */
1720                 6, 1, "foo"
1721         },
1722         {
1723                 /* [30] fe:ff:00:66:00:6f:00:6f */
1724                 7, 1, "foo"
1725         },
1726         {
1727                 /* [30] ff:fe:66:00:6f:00:6f:00 */
1728                 8, 1, "foo"
1729         },
1730         {
1731                 /* [20] 63:61:66:e9 */
1732                 9, 1, "caf\xC3\xA9"
1733         },
1734         {
1735                 /* [12] 63:61:66:c3:a9 */
1736                 10, 1, "caf\xC3\xA9"
1737         },
1738         {
1739                 /* [12] 63:61:66:e0:83:a9 */
1740                 11, -1, NULL
1741         },
1742         {
1743                 /* [12] 63:61:66:e3:90:8c */
1744                 12, 1, "caf\xE3\x90\x8C"
1745         },
1746         {
1747                 /* [30] 00:63:00:61:00:66:34:0c */
1748                 13, 1, "caf\xE3\x90\x8C"
1749         },
1750         {
1751                 /* [12] 63:61:66:c3 */
1752                 14, -1, NULL
1753         },
1754         {
1755                 /* [30] d8:42:df:f4:00:67:00:6f */
1756                 15, 1, "\xF0\xA0\xAF\xB4go"
1757         },
1758         {
1759                 /* [30] 00:66:d8:42 */
1760                 16, -1, NULL
1761         },
1762         {
1763                 /* [30] d8:42:00:66 */
1764                 17, -1, NULL
1765         },
1766         {
1767                 /* [30] df:f4:00:66 */
1768                 18, -1, NULL
1769         },
1770         {
1771                 /* [12] 66:00:6f */
1772                 19, -1, NULL
1773         },
1774         {
1775                 /* [30] 00:00:34:0c */
1776                 20, -1, NULL
1777         },
1778         {
1779                 /* [30] 34:0c:00:00:00:66 */
1780                 21, -1, NULL
1781         },
1782         {
1783                 /* [12] ef:bb:bf:66:6f:6f */
1784                 22, 1, "foo"
1785         },
1786         {
1787                 /* [30] 00:66:ff:fe:00:6f */
1788                 23, -1, NULL
1789         },
1790         {
1791                 /* [30] 00:66:ff:fd:00:6f */
1792                 24, 1, "f\xEF\xBF\xBDo"
1793         },
1794
1795         /* === Value not found in the DN === */
1796         {
1797                 127, 0, NULL
1798         },
1799
1800         /* === SAN tests === */
1801         {
1802                 /* SAN OtherName (Microsoft UPN) */
1803                 0, 1, "foo@bar.com"
1804         },
1805         {
1806                 /* SAN rfc822Name */
1807                 -1, 1, "bar@foo.com"
1808         },
1809         {
1810                 /* SAN dNSName */
1811                 -2, 1, "example.com"
1812         },
1813         {
1814                 /* SAN dNSName */
1815                 -2, 1, "www.example.com"
1816         },
1817         {
1818                 /* uniformResourceIdentifier */
1819                 -6, 1, "http://www.example.com/"
1820         }
1821 };
1822
1823 static void
1824 free_name_elements(br_name_element *elts, size_t num)
1825 {
1826         size_t u;
1827
1828         for (u = 0; u < num; u ++) {
1829                 xfree((void *)elts[u].oid);
1830                 xfree(elts[u].buf);
1831         }
1832         xfree(elts);
1833 }
1834
1835 static void
1836 test_name_extraction(void)
1837 {
1838         unsigned char *data;
1839         size_t len;
1840         br_x509_minimal_context ctx;
1841         uint32_t days, seconds;
1842         size_t u;
1843         unsigned status;
1844         br_name_element *names;
1845         size_t num_names;
1846         int good;
1847
1848         printf("Name extraction: ");
1849         fflush(stdout);
1850         data = read_file("names.crt", &len);
1851         br_x509_minimal_init(&ctx, &br_sha256_vtable, NULL, 0);
1852         for (u = 0; hash_impls[u].id; u ++) {
1853                 int id;
1854
1855                 id = hash_impls[u].id;
1856                 br_x509_minimal_set_hash(&ctx, id, hash_impls[u].impl);
1857         }
1858         br_x509_minimal_set_rsa(&ctx, br_rsa_pkcs1_vrfy_get_default());
1859         br_x509_minimal_set_ecdsa(&ctx,
1860                 br_ec_get_default(), br_ecdsa_vrfy_asn1_get_default());
1861         string_to_time(DEFAULT_TIME, &days, &seconds);
1862         br_x509_minimal_set_time(&ctx, days, seconds);
1863
1864         num_names = (sizeof names_ref) / (sizeof names_ref[0]);
1865         names = xmalloc(num_names * sizeof *names);
1866         for (u = 0; u < num_names; u ++) {
1867                 int num;
1868                 unsigned char *oid;
1869
1870                 num = names_ref[u].num;
1871                 if (num > 0) {
1872                         oid = xmalloc(5);
1873                         oid[0] = 4;
1874                         oid[1] = 0x29;
1875                         oid[2] = 0x01;
1876                         oid[3] = 0x01;
1877                         oid[4] = num;
1878                 } else if (num == 0) {
1879                         oid = xmalloc(13);
1880                         oid[0] = 0x00;
1881                         oid[1] = 0x00;
1882                         oid[2] = 0x0A;
1883                         oid[3] = 0x2B;
1884                         oid[4] = 0x06;
1885                         oid[5] = 0x01;
1886                         oid[6] = 0x04;
1887                         oid[7] = 0x01;
1888                         oid[8] = 0x82;
1889                         oid[9] = 0x37;
1890                         oid[10] = 0x14;
1891                         oid[11] = 0x02;
1892                         oid[12] = 0x03;
1893                 } else {
1894                         oid = xmalloc(2);
1895                         oid[0] = 0x00;
1896                         oid[1] = -num;
1897                 }
1898                 names[u].oid = oid;
1899                 names[u].buf = xmalloc(256);
1900                 names[u].len = 256;
1901         }
1902         br_x509_minimal_set_name_elements(&ctx, names, num_names);
1903
1904         /*
1905          * Put "canaries" to detect actual stack usage.
1906          */
1907         for (u = 0; u < (sizeof ctx.dp_stack) / sizeof(uint32_t); u ++) {
1908                 ctx.dp_stack[u] = 0xA7C083FE;
1909         }
1910         for (u = 0; u < (sizeof ctx.rp_stack) / sizeof(uint32_t); u ++) {
1911                 ctx.rp_stack[u] = 0xA7C083FE;
1912         }
1913
1914         /*
1915          * Run the engine. Since we set no trust anchor, we expect a status
1916          * of "not trusted".
1917          */
1918         ctx.vtable->start_chain(&ctx.vtable, NULL);
1919         ctx.vtable->start_cert(&ctx.vtable, len);
1920         ctx.vtable->append(&ctx.vtable, data, len);
1921         ctx.vtable->end_cert(&ctx.vtable);
1922         status = ctx.vtable->end_chain(&ctx.vtable);
1923         if (status != BR_ERR_X509_NOT_TRUSTED) {
1924                 fprintf(stderr, "wrong status: %u\n", status);
1925                 exit(EXIT_FAILURE);
1926         }
1927
1928         /*
1929          * Check stack usage.
1930          */
1931         for (u = (sizeof ctx.dp_stack) / sizeof(uint32_t); u > 0; u --) {
1932                 if (ctx.dp_stack[u - 1] != 0xA7C083FE) {
1933                         if (max_dp_usage < u) {
1934                                 max_dp_usage = u;
1935                         }
1936                         break;
1937                 }
1938         }
1939         for (u = (sizeof ctx.rp_stack) / sizeof(uint32_t); u > 0; u --) {
1940                 if (ctx.rp_stack[u - 1] != 0xA7C083FE) {
1941                         if (max_rp_usage < u) {
1942                                 max_rp_usage = u;
1943                         }
1944                         break;
1945                 }
1946         }
1947
1948         good = 1;
1949         for (u = 0; u < num_names; u ++) {
1950                 if (names[u].status != names_ref[u].status) {
1951                         printf("ERR: name %u (id=%d): status=%d, expected=%d\n",
1952                                 (unsigned)u, names_ref[u].num,
1953                                 names[u].status, names_ref[u].status);
1954                         if (names[u].status > 0) {
1955                                 unsigned char *p;
1956
1957                                 printf("  obtained:");
1958                                 p = (unsigned char *)names[u].buf;
1959                                 while (*p) {
1960                                         printf(" %02X", *p ++);
1961                                 }
1962                                 printf("\n");
1963                         }
1964                         good = 0;
1965                         continue;
1966                 }
1967                 if (names_ref[u].expected == NULL) {
1968                         if (names[u].buf[0] != 0) {
1969                                 printf("ERR: name %u not zero-terminated\n",
1970                                         (unsigned)u);
1971                                 good = 0;
1972                                 continue;
1973                         }
1974                 } else {
1975                         if (strcmp(names[u].buf, names_ref[u].expected) != 0) {
1976                                 unsigned char *p;
1977
1978                                 printf("ERR: name %u (id=%d): wrong value\n",
1979                                         (unsigned)u, names_ref[u].num);
1980                                 printf("  expected:");
1981                                 p = (unsigned char *)names_ref[u].expected;
1982                                 while (*p) {
1983                                         printf(" %02X", *p ++);
1984                                 }
1985                                 printf("\n");
1986                                 printf("  obtained:");
1987                                 p = (unsigned char *)names[u].buf;
1988                                 while (*p) {
1989                                         printf(" %02X", *p ++);
1990                                 }
1991                                 printf("\n");
1992                                 good = 0;
1993                                 continue;
1994                         }
1995                 }
1996         }
1997         if (!good) {
1998                 exit(EXIT_FAILURE);
1999         }
2000
2001         /*
2002         for (u = 0; u < num_names; u ++) {
2003                 printf("%u: (%d)", (unsigned)u, names[u].status);
2004                 if (names[u].status > 0) {
2005                         size_t v;
2006
2007                         for (v = 0; names[u].buf[v]; v ++) {
2008                                 printf(" %02x", names[u].buf[v]);
2009                         }
2010                 }
2011                 printf("\n");
2012         }
2013         */
2014
2015         xfree(data);
2016         free_name_elements(names, num_names);
2017         printf("OK\n");
2018 }
2019
2020 int
2021 main(int argc, const char *argv[])
2022 {
2023         size_t u;
2024
2025 #ifdef SRCDIRNAME
2026         /*
2027          * We want to change the current directory to that of the
2028          * executable, so that test files are reliably located. We
2029          * do that only if SRCDIRNAME is defined (old Makefile would
2030          * not do that).
2031          */
2032         if (argc >= 1) {
2033                 const char *arg, *c;
2034
2035                 arg = argv[0];
2036                 for (c = arg + strlen(arg);; c --) {
2037                         int sep, r;
2038
2039 #ifdef _WIN32
2040                         sep = (*c == '/') || (*c == '\\');
2041 #else
2042                         sep = (*c == '/');
2043 #endif
2044                         if (sep) {
2045                                 size_t len;
2046                                 char *dn;
2047
2048                                 len = 1 + (c - arg);
2049                                 dn = xmalloc(len + 1);
2050                                 memcpy(dn, arg, len);
2051                                 dn[len] = 0;
2052 #ifdef _WIN32
2053                                 r = _chdir(dn);
2054 #else
2055                                 r = chdir(dn);
2056 #endif
2057                                 if (r != 0) {
2058                                         fprintf(stderr, "warning: could not"
2059                                                 " set directory to '%s'\n", dn);
2060                                 }
2061                                 xfree(dn);
2062                                 break;
2063                         }
2064                         if (c == arg) {
2065                                 break;
2066                         }
2067                 }
2068         }
2069 #else
2070         (void)argc;
2071         (void)argv;
2072 #endif
2073
2074         process_conf_file(CONFFILE);
2075
2076         max_dp_usage = 0;
2077         max_rp_usage = 0;
2078         for (u = 0; u < all_chains_ptr; u ++) {
2079                 run_test_case(&all_chains[u]);
2080         }
2081         test_name_extraction();
2082
2083         printf("Maximum data stack usage:    %u\n", (unsigned)max_dp_usage);
2084         printf("Maximum return stack usage:  %u\n", (unsigned)max_rp_usage);
2085
2086         HT_free(keys, free_key);
2087         HT_free(trust_anchors, free_trust_anchor);
2088         for (u = 0; u < all_chains_ptr; u ++) {
2089                 free_test_case_contents(&all_chains[u]);
2090         }
2091         xfree(all_chains);
2092
2093         return 0;
2094 }