lib/libcrypto/conf/conf_def.c

   1 /* $OpenBSD: conf_def.c,v 1.32 2017/01/29 17:49:22 beck Exp $ */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 /* Part of the code in here was originally in conf.c, which is now removed */
  60
  61 #include <stdio.h>
  62 #include <string.h>
  63
  64 #include <openssl/buffer.h>
  65 #include <openssl/conf.h>
  66 #include <openssl/conf_api.h>
  67 #include <openssl/err.h>
  68 #include <openssl/lhash.h>
  69 #include <openssl/stack.h>
  70
  71 #include "conf_def.h"
  72
  73 static char *eat_ws(CONF *conf, char *p);
  74 static char *eat_alpha_numeric(CONF *conf, char *p);
  75 static void clear_comments(CONF *conf, char *p);
  76 static int str_copy(CONF *conf, char *section, char **to, char *from);
  77 static char *scan_quote(CONF *conf, char *p);
  78 static char *scan_dquote(CONF *conf, char *p);
  79 #define scan_esc(conf,p)        (((IS_EOF((conf),(p)[1]))?((p)+1):((p)+2)))
  80
  81 static CONF *def_create(CONF_METHOD *meth);
  82 static int def_init_default(CONF *conf);
  83 static int def_init_WIN32(CONF *conf);
  84 static int def_destroy(CONF *conf);
  85 static int def_destroy_data(CONF *conf);
  86 static int def_load(CONF *conf, const char *name, long *eline);
  87 static int def_load_bio(CONF *conf, BIO *bp, long *eline);
  88 static int def_dump(const CONF *conf, BIO *bp);
  89 static int def_is_number(const CONF *conf, char c);
  90 static int def_to_int(const CONF *conf, char c);
  91
  92 static CONF_METHOD default_method = {
  93         .name = "OpenSSL default",
  94         .create = def_create,
  95         .init = def_init_default,
  96         .destroy = def_destroy,
  97         .destroy_data = def_destroy_data,
  98         .load_bio = def_load_bio,
  99         .dump = def_dump,
 100         .is_number = def_is_number,
 101         .to_int = def_to_int,
 102         .load = def_load
 103 };
 104
 105 static CONF_METHOD WIN32_method = {
 106         "WIN32",
 107         def_create,
 108         def_init_WIN32,
 109         def_destroy,
 110         def_destroy_data,
 111         def_load_bio,
 112         def_dump,
 113         def_is_number,
 114         def_to_int,
 115         def_load
 116 };
 117
 118 CONF_METHOD *
 119 NCONF_default(void)
 120 {
 121         return &default_method;
 122 }
 123
 124 CONF_METHOD *
 125 NCONF_WIN32(void)
 126 {
 127         return &WIN32_method;
 128 }
 129
 130 static CONF *
 131 def_create(CONF_METHOD *meth)
 132 {
 133         CONF *ret;
 134
 135         ret = malloc(sizeof(CONF) + sizeof(unsigned short *));
 136         if (ret)
 137                 if (meth->init(ret) == 0) {
 138                         free(ret);
 139                         ret = NULL;
 140                 }
 141         return ret;
 142 }
 143
 144 static int
 145 def_init_default(CONF *conf)
 146 {
 147         if (conf == NULL)
 148                 return 0;
 149
 150         conf->meth = &default_method;
 151         conf->meth_data = CONF_type_default;
 152         conf->data = NULL;
 153
 154         return 1;
 155 }
 156
 157 static int
 158 def_init_WIN32(CONF *conf)
 159 {
 160         if (conf == NULL)
 161                 return 0;
 162
 163         conf->meth = &WIN32_method;
 164         conf->meth_data = (void *)CONF_type_win32;
 165         conf->data = NULL;
 166
 167         return 1;
 168 }
 169
 170 static int
 171 def_destroy(CONF *conf)
 172 {
 173         if (def_destroy_data(conf)) {
 174                 free(conf);
 175                 return 1;
 176         }
 177         return 0;
 178 }
 179
 180 static int
 181 def_destroy_data(CONF *conf)
 182 {
 183         if (conf == NULL)
 184                 return 0;
 185         _CONF_free_data(conf);
 186         return 1;
 187 }
 188
 189 static int
 190 def_load(CONF *conf, const char *name, long *line)
 191 {
 192         int ret;
 193         BIO *in = NULL;
 194
 195         in = BIO_new_file(name, "rb");
 196         if (in == NULL) {
 197                 if (ERR_GET_REASON(ERR_peek_last_error()) == BIO_R_NO_SUCH_FILE)
 198                         CONFerror(CONF_R_NO_SUCH_FILE);
 199                 else
 200                         CONFerror(ERR_R_SYS_LIB);
 201                 return 0;
 202         }
 203
 204         ret = def_load_bio(conf, in, line);
 205         BIO_free(in);
 206
 207         return ret;
 208 }
 209
 210 static int
 211 def_load_bio(CONF *conf, BIO *in, long *line)
 212 {
 213 /* The macro BUFSIZE conflicts with a system macro in VxWorks */
 214 #define CONFBUFSIZE     512
 215         int bufnum = 0, i, ii;
 216         BUF_MEM *buff = NULL;
 217         char *s, *p, *end;
 218         int again;
 219         long eline = 0;
 220         CONF_VALUE *v = NULL, *tv;
 221         CONF_VALUE *sv = NULL;
 222         char *section = NULL, *buf;
 223         char *start, *psection, *pname;
 224         void *h = (void *)(conf->data);
 225
 226         if ((buff = BUF_MEM_new()) == NULL) {
 227                 CONFerror(ERR_R_BUF_LIB);
 228                 goto err;
 229         }
 230
 231         section = strdup("default");
 232         if (section == NULL) {
 233                 CONFerror(ERR_R_MALLOC_FAILURE);
 234                 goto err;
 235         }
 236
 237         if (_CONF_new_data(conf) == 0) {
 238                 CONFerror(ERR_R_MALLOC_FAILURE);
 239                 goto err;
 240         }
 241
 242         sv = _CONF_new_section(conf, section);
 243         if (sv == NULL) {
 244                 CONFerror(CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
 245                 goto err;
 246         }
 247
 248         bufnum = 0;
 249         again = 0;
 250         for (;;) {
 251                 if (!BUF_MEM_grow(buff, bufnum + CONFBUFSIZE)) {
 252                         CONFerror(ERR_R_BUF_LIB);
 253                         goto err;
 254                 }
 255                 p = &(buff->data[bufnum]);
 256                 *p = '\0';
 257                 BIO_gets(in, p, CONFBUFSIZE - 1);
 258                 p[CONFBUFSIZE - 1] = '\0';
 259                 ii = i = strlen(p);
 260                 if (i == 0 && !again)
 261                         break;
 262                 again = 0;
 263                 while (i > 0) {
 264                         if ((p[i - 1] != '\r') && (p[i - 1] != '\n'))
 265                                 break;
 266                         else
 267                                 i--;
 268                 }
 269                 /* we removed some trailing stuff so there is a new
 270                  * line on the end. */
 271                 if (ii && i == ii)
 272                         again = 1; /* long line */
 273                 else {
 274                         p[i] = '\0';
 275                         eline++; /* another input line */
 276                 }
 277
 278                 /* we now have a line with trailing \r\n removed */
 279
 280                 /* i is the number of bytes */
 281                 bufnum += i;
 282
 283                 v = NULL;
 284                 /* check for line continuation */
 285                 if (bufnum >= 1) {
 286                         /* If we have bytes and the last char '\\' and
 287                          * second last char is not '\\' */
 288                         p = &(buff->data[bufnum - 1]);
 289                         if (IS_ESC(conf, p[0]) &&
 290                             ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) {
 291                                 bufnum--;
 292                                 again = 1;
 293                         }
 294                 }
 295                 if (again)
 296                         continue;
 297                 bufnum = 0;
 298                 buf = buff->data;
 299
 300                 clear_comments(conf, buf);
 301                 s = eat_ws(conf, buf);
 302                 if (IS_EOF(conf, *s))
 303                         continue; /* blank line */
 304                 if (*s == '[') {
 305                         char *ss;
 306
 307                         s++;
 308                         start = eat_ws(conf, s);
 309                         ss = start;
 310 again:
 311                         end = eat_alpha_numeric(conf, ss);
 312                         p = eat_ws(conf, end);
 313                         if (*p != ']') {
 314                                 if (*p != '\0' && ss != p) {
 315                                         ss = p;
 316                                         goto again;
 317                                 }
 318                                 CONFerror(CONF_R_MISSING_CLOSE_SQUARE_BRACKET);
 319                                 goto err;
 320                         }
 321                         *end = '\0';
 322                         if (!str_copy(conf, NULL, &section, start))
 323                                 goto err;
 324                         if ((sv = _CONF_get_section(conf, section)) == NULL)
 325                                 sv = _CONF_new_section(conf, section);
 326                         if (sv == NULL) {
 327                                 CONFerror(CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
 328                                 goto err;
 329                         }
 330                         continue;
 331                 } else {
 332                         pname = s;
 333                         psection = NULL;
 334                         end = eat_alpha_numeric(conf, s);
 335                         if ((end[0] == ':') && (end[1] == ':')) {
 336                                 *end = '\0';
 337                                 end += 2;
 338                                 psection = pname;
 339                                 pname = end;
 340                                 end = eat_alpha_numeric(conf, end);
 341                         }
 342                         p = eat_ws(conf, end);
 343                         if (*p != '=') {
 344                                 CONFerror(CONF_R_MISSING_EQUAL_SIGN);
 345                                 goto err;
 346                         }
 347                         *end = '\0';
 348                         p++;
 349                         start = eat_ws(conf, p);
 350                         while (!IS_EOF(conf, *p))
 351                                 p++;
 352                         p--;
 353                         while ((p != start) && (IS_WS(conf, *p)))
 354                                 p--;
 355                         p++;
 356                         *p = '\0';
 357
 358                         if (!(v = malloc(sizeof(CONF_VALUE)))) {
 359                                 CONFerror(ERR_R_MALLOC_FAILURE);
 360                                 goto err;
 361                         }
 362                         if (psection == NULL)
 363                                 psection = section;
 364                         v->name = strdup(pname);
 365                         v->value = NULL;
 366                         if (v->name == NULL) {
 367                                 CONFerror(ERR_R_MALLOC_FAILURE);
 368                                 goto err;
 369                         }
 370                         if (!str_copy(conf, psection, &(v->value), start))
 371                                 goto err;
 372
 373                         if (strcmp(psection, section) != 0) {
 374                                 if ((tv = _CONF_get_section(conf, psection))
 375                                         == NULL)
 376                                         tv = _CONF_new_section(conf, psection);
 377                                 if (tv == NULL) {
 378                                         CONFerror(CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
 379                                         goto err;
 380                                 }
 381                         } else
 382                                 tv = sv;
 383
 384                         if (_CONF_add_string(conf, tv, v) == 0) {
 385                                 CONFerror(ERR_R_MALLOC_FAILURE);
 386                                 goto err;
 387                         }
 388                         v = NULL;
 389                 }
 390         }
 391         if (buff != NULL)
 392                 BUF_MEM_free(buff);
 393         free(section);
 394         return (1);
 395
 396 err:
 397         if (buff != NULL)
 398                 BUF_MEM_free(buff);
 399         free(section);
 400         if (line != NULL)
 401                 *line = eline;
 402         ERR_asprintf_error_data("line %ld", eline);
 403         if ((h != conf->data) && (conf->data != NULL)) {
 404                 CONF_free(conf->data);
 405                 conf->data = NULL;
 406         }
 407         if (v != NULL) {
 408                 free(v->name);
 409                 free(v->value);
 410                 free(v);
 411         }
 412         return (0);
 413 }
 414
 415 static void
 416 clear_comments(CONF *conf, char *p)
 417 {
 418         for (;;) {
 419                 if (IS_FCOMMENT(conf, *p)) {
 420                         *p = '\0';
 421                         return;
 422                 }
 423                 if (!IS_WS(conf, *p)) {
 424                         break;
 425                 }
 426                 p++;
 427         }
 428
 429         for (;;) {
 430                 if (IS_COMMENT(conf, *p)) {
 431                         *p = '\0';
 432                         return;
 433                 }
 434                 if (IS_DQUOTE(conf, *p)) {
 435                         p = scan_dquote(conf, p);
 436                         continue;
 437                 }
 438                 if (IS_QUOTE(conf, *p)) {
 439                         p = scan_quote(conf, p);
 440                         continue;
 441                 }
 442                 if (IS_ESC(conf, *p)) {
 443                         p = scan_esc(conf, p);
 444                         continue;
 445                 }
 446                 if (IS_EOF(conf, *p))
 447                         return;
 448                 else
 449                         p++;
 450         }
 451 }
 452
 453 static int
 454 str_copy(CONF *conf, char *section, char **pto, char *from)
 455 {
 456         int q, r,rr = 0, to = 0, len = 0;
 457         char *s, *e, *rp, *p, *rrp, *np, *cp, v;
 458         BUF_MEM *buf;
 459
 460         if ((buf = BUF_MEM_new()) == NULL)
 461                 return (0);
 462
 463         len = strlen(from) + 1;
 464         if (!BUF_MEM_grow(buf, len))
 465                 goto err;
 466
 467         for (;;) {
 468                 if (IS_QUOTE(conf, *from)) {
 469                         q = *from;
 470                         from++;
 471                         while (!IS_EOF(conf, *from) && (*from != q)) {
 472                                 if (IS_ESC(conf, *from)) {
 473                                         from++;
 474                                         if (IS_EOF(conf, *from))
 475                                                 break;
 476                                 }
 477                                 buf->data[to++] = *(from++);
 478                         }
 479                         if (*from == q)
 480                                 from++;
 481                 } else if (IS_DQUOTE(conf, *from)) {
 482                         q = *from;
 483                         from++;
 484                         while (!IS_EOF(conf, *from)) {
 485                                 if (*from == q) {
 486                                         if (*(from + 1) == q) {
 487                                                 from++;
 488                                         } else {
 489                                                 break;
 490                                         }
 491                                 }
 492                                 buf->data[to++] = *(from++);
 493                         }
 494                         if (*from == q)
 495                                 from++;
 496                 } else if (IS_ESC(conf, *from)) {
 497                         from++;
 498                         v = *(from++);
 499                         if (IS_EOF(conf, v))
 500                                 break;
 501                         else if (v == 'r')
 502                                 v = '\r';
 503                         else if (v == 'n')
 504                                 v = '\n';
 505                         else if (v == 'b')
 506                                 v = '\b';
 507                         else if (v == 't')
 508                                 v = '\t';
 509                         buf->data[to++] = v;
 510                 } else if (IS_EOF(conf, *from))
 511                         break;
 512                 else if (*from == '$') {
 513                         /* try to expand it */
 514                         rrp = NULL;
 515                         s = &(from[1]);
 516                         if (*s == '{')
 517                                 q = '}';
 518                         else if (*s == '(')
 519                                 q = ')';
 520                         else
 521                                 q = 0;
 522
 523                         if (q)
 524                                 s++;
 525                         cp = section;
 526                         e = np = s;
 527                         while (IS_ALPHA_NUMERIC(conf, *e))
 528                                 e++;
 529                         if ((e[0] == ':') && (e[1] == ':')) {
 530                                 cp = np;
 531                                 rrp = e;
 532                                 rr = *e;
 533                                 *rrp = '\0';
 534                                 e += 2;
 535                                 np = e;
 536                                 while (IS_ALPHA_NUMERIC(conf, *e))
 537                                         e++;
 538                         }
 539                         r = *e;
 540                         *e = '\0';
 541                         rp = e;
 542                         if (q) {
 543                                 if (r != q) {
 544                                         CONFerror(CONF_R_NO_CLOSE_BRACE);
 545                                         goto err;
 546                                 }
 547                                 e++;
 548                         }
 549                         /* So at this point we have
 550                          * np which is the start of the name string which is
 551                          *   '\0' terminated.
 552                          * cp which is the start of the section string which is
 553                          *   '\0' terminated.
 554                          * e is the 'next point after'.
 555                          * r and rr are the chars replaced by the '\0'
 556                          * rp and rrp is where 'r' and 'rr' came from.
 557                          */
 558                         p = _CONF_get_string(conf, cp, np);
 559                         if (rrp != NULL)
 560                                 *rrp = rr;
 561                         *rp = r;
 562                         if (p == NULL) {
 563                                 CONFerror(CONF_R_VARIABLE_HAS_NO_VALUE);
 564                                 goto err;
 565                         }
 566                         if (!BUF_MEM_grow_clean(buf,
 567                                 (strlen(p) + buf->length - (e - from)))) {
 568                                 CONFerror(CONF_R_MODULE_INITIALIZATION_ERROR);
 569                                 goto err;
 570                         }
 571                         while (*p)
 572                                 buf->data[to++] = *(p++);
 573
 574                         /* Since we change the pointer 'from', we also have
 575                            to change the perceived length of the string it
 576                            points at.  /RL */
 577                         len -= e - from;
 578                         from = e;
 579
 580                         /* In case there were no braces or parenthesis around
 581                            the variable reference, we have to put back the
 582                            character that was replaced with a '\0'.  /RL */
 583                         *rp = r;
 584                 } else
 585                         buf->data[to++] = *(from++);
 586         }
 587         buf->data[to]='\0';
 588         free(*pto);
 589         *pto = buf->data;
 590         free(buf);
 591         return (1);
 592
 593 err:
 594         if (buf != NULL)
 595                 BUF_MEM_free(buf);
 596         return (0);
 597 }
 598
 599 static char *
 600 eat_ws(CONF *conf, char *p)
 601 {
 602         while (IS_WS(conf, *p) && (!IS_EOF(conf, *p)))
 603                 p++;
 604         return (p);
 605 }
 606
 607 static char *
 608 eat_alpha_numeric(CONF *conf, char *p)
 609 {
 610         for (;;) {
 611                 if (IS_ESC(conf, *p)) {
 612                         p = scan_esc(conf, p);
 613                         continue;
 614                 }
 615                 if (!IS_ALPHA_NUMERIC_PUNCT(conf, *p))
 616                         return (p);
 617                 p++;
 618         }
 619 }
 620
 621 static char *
 622 scan_quote(CONF *conf, char *p)
 623 {
 624         int q = *p;
 625
 626         p++;
 627         while (!(IS_EOF(conf, *p)) && (*p != q)) {
 628                 if (IS_ESC(conf, *p)) {
 629                         p++;
 630                         if (IS_EOF(conf, *p))
 631                                 return (p);
 632                 }
 633                 p++;
 634         }
 635         if (*p == q)
 636                 p++;
 637         return (p);
 638 }
 639
 640
 641 static char *
 642 scan_dquote(CONF *conf, char *p)
 643 {
 644         int q = *p;
 645
 646         p++;
 647         while (!(IS_EOF(conf, *p))) {
 648                 if (*p == q) {
 649                         if (*(p + 1) == q) {
 650                                 p++;
 651                         } else {
 652                                 break;
 653                         }
 654                 }
 655                 p++;
 656         }
 657         if (*p == q)
 658                 p++;
 659         return (p);
 660 }
 661
 662 static void
 663 dump_value_doall_arg(CONF_VALUE *a, BIO *out)
 664 {
 665         if (a->name)
 666                 BIO_printf(out, "[%s] %s=%s\n", a->section, a->name, a->value);
 667         else
 668                 BIO_printf(out, "[[%s]]\n", a->section);
 669 }
 670
 671 static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE, BIO)
 672
 673 static int
 674 def_dump(const CONF *conf, BIO *out)
 675 {
 676         lh_CONF_VALUE_doall_arg(conf->data, LHASH_DOALL_ARG_FN(dump_value),
 677             BIO, out);
 678         return 1;
 679 }
 680
 681 static int
 682 def_is_number(const CONF *conf, char c)
 683 {
 684         return IS_NUMBER(conf, c);
 685 }
 686
 687 static int
 688 def_to_int(const CONF *conf, char c)
 689 {
 690         return c - '0';
 691 }