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 }
692