1 /* $OpenBSD: conf_def.c,v 1.30 2015/04/30 15:28:03 deraadt 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 			CONFerr(CONF_F_DEF_LOAD, CONF_R_NO_SUCH_FILE);
199 		else
200 			CONFerr(CONF_F_DEF_LOAD, 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 		CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_BUF_LIB);
228 		goto err;
229 	}
230 
231 	section = strdup("default");
232 	if (section == NULL) {
233 		CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
234 		goto err;
235 	}
236 
237 	if (_CONF_new_data(conf) == 0) {
238 		CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
239 		goto err;
240 	}
241 
242 	sv = _CONF_new_section(conf, section);
243 	if (sv == NULL) {
244 		CONFerr(CONF_F_DEF_LOAD_BIO,
245 		    CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
246 		goto err;
247 	}
248 
249 	bufnum = 0;
250 	again = 0;
251 	for (;;) {
252 		if (!BUF_MEM_grow(buff, bufnum + CONFBUFSIZE)) {
253 			CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_BUF_LIB);
254 			goto err;
255 		}
256 		p = &(buff->data[bufnum]);
257 		*p = '\0';
258 		BIO_gets(in, p, CONFBUFSIZE - 1);
259 		p[CONFBUFSIZE - 1] = '\0';
260 		ii = i = strlen(p);
261 		if (i == 0 && !again)
262 			break;
263 		again = 0;
264 		while (i > 0) {
265 			if ((p[i - 1] != '\r') && (p[i - 1] != '\n'))
266 				break;
267 			else
268 				i--;
269 		}
270 		/* we removed some trailing stuff so there is a new
271 		 * line on the end. */
272 		if (ii && i == ii)
273 			again = 1; /* long line */
274 		else {
275 			p[i] = '\0';
276 			eline++; /* another input line */
277 		}
278 
279 		/* we now have a line with trailing \r\n removed */
280 
281 		/* i is the number of bytes */
282 		bufnum += i;
283 
284 		v = NULL;
285 		/* check for line continuation */
286 		if (bufnum >= 1) {
287 			/* If we have bytes and the last char '\\' and
288 			 * second last char is not '\\' */
289 			p = &(buff->data[bufnum - 1]);
290 			if (IS_ESC(conf, p[0]) &&
291 			    ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) {
292 				bufnum--;
293 				again = 1;
294 			}
295 		}
296 		if (again)
297 			continue;
298 		bufnum = 0;
299 		buf = buff->data;
300 
301 		clear_comments(conf, buf);
302 		s = eat_ws(conf, buf);
303 		if (IS_EOF(conf, *s))
304 			continue; /* blank line */
305 		if (*s == '[') {
306 			char *ss;
307 
308 			s++;
309 			start = eat_ws(conf, s);
310 			ss = start;
311 again:
312 			end = eat_alpha_numeric(conf, ss);
313 			p = eat_ws(conf, end);
314 			if (*p != ']') {
315 				if (*p != '\0' && ss != p) {
316 					ss = p;
317 					goto again;
318 				}
319 				CONFerr(CONF_F_DEF_LOAD_BIO,
320 				    CONF_R_MISSING_CLOSE_SQUARE_BRACKET);
321 				goto err;
322 			}
323 			*end = '\0';
324 			if (!str_copy(conf, NULL, &section, start))
325 				goto err;
326 			if ((sv = _CONF_get_section(conf, section)) == NULL)
327 				sv = _CONF_new_section(conf, section);
328 			if (sv == NULL) {
329 				CONFerr(CONF_F_DEF_LOAD_BIO,
330 				    CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
331 				goto err;
332 			}
333 			continue;
334 		} else {
335 			pname = s;
336 			psection = NULL;
337 			end = eat_alpha_numeric(conf, s);
338 			if ((end[0] == ':') && (end[1] == ':')) {
339 				*end = '\0';
340 				end += 2;
341 				psection = pname;
342 				pname = end;
343 				end = eat_alpha_numeric(conf, end);
344 			}
345 			p = eat_ws(conf, end);
346 			if (*p != '=') {
347 				CONFerr(CONF_F_DEF_LOAD_BIO,
348 				    CONF_R_MISSING_EQUAL_SIGN);
349 				goto err;
350 			}
351 			*end = '\0';
352 			p++;
353 			start = eat_ws(conf, p);
354 			while (!IS_EOF(conf, *p))
355 				p++;
356 			p--;
357 			while ((p != start) && (IS_WS(conf, *p)))
358 				p--;
359 			p++;
360 			*p = '\0';
361 
362 			if (!(v = malloc(sizeof(CONF_VALUE)))) {
363 				CONFerr(CONF_F_DEF_LOAD_BIO,
364 				    ERR_R_MALLOC_FAILURE);
365 				goto err;
366 			}
367 			if (psection == NULL)
368 				psection = section;
369 			v->name = strdup(pname);
370 			v->value = NULL;
371 			if (v->name == NULL) {
372 				CONFerr(CONF_F_DEF_LOAD_BIO,
373 				    ERR_R_MALLOC_FAILURE);
374 				goto err;
375 			}
376 			if (!str_copy(conf, psection, &(v->value), start))
377 				goto err;
378 
379 			if (strcmp(psection, section) != 0) {
380 				if ((tv = _CONF_get_section(conf, psection))
381 					== NULL)
382 					tv = _CONF_new_section(conf, psection);
383 				if (tv == NULL) {
384 					CONFerr(CONF_F_DEF_LOAD_BIO,
385 					    CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
386 					goto err;
387 				}
388 			} else
389 				tv = sv;
390 
391 			if (_CONF_add_string(conf, tv, v) == 0) {
392 				CONFerr(CONF_F_DEF_LOAD_BIO,
393 				    ERR_R_MALLOC_FAILURE);
394 				goto err;
395 			}
396 			v = NULL;
397 		}
398 	}
399 	if (buff != NULL)
400 		BUF_MEM_free(buff);
401 	free(section);
402 	return (1);
403 
404 err:
405 	if (buff != NULL)
406 		BUF_MEM_free(buff);
407 	free(section);
408 	if (line != NULL)
409 		*line = eline;
410 	ERR_asprintf_error_data("line %ld", eline);
411 	if ((h != conf->data) && (conf->data != NULL)) {
412 		CONF_free(conf->data);
413 		conf->data = NULL;
414 	}
415 	if (v != NULL) {
416 		free(v->name);
417 		free(v->value);
418 		free(v);
419 	}
420 	return (0);
421 }
422 
423 static void
424 clear_comments(CONF *conf, char *p)
425 {
426 	for (;;) {
427 		if (IS_FCOMMENT(conf, *p)) {
428 			*p = '\0';
429 			return;
430 		}
431 		if (!IS_WS(conf, *p)) {
432 			break;
433 		}
434 		p++;
435 	}
436 
437 	for (;;) {
438 		if (IS_COMMENT(conf, *p)) {
439 			*p = '\0';
440 			return;
441 		}
442 		if (IS_DQUOTE(conf, *p)) {
443 			p = scan_dquote(conf, p);
444 			continue;
445 		}
446 		if (IS_QUOTE(conf, *p)) {
447 			p = scan_quote(conf, p);
448 			continue;
449 		}
450 		if (IS_ESC(conf, *p)) {
451 			p = scan_esc(conf, p);
452 			continue;
453 		}
454 		if (IS_EOF(conf, *p))
455 			return;
456 		else
457 			p++;
458 	}
459 }
460 
461 static int
462 str_copy(CONF *conf, char *section, char **pto, char *from)
463 {
464 	int q, r,rr = 0, to = 0, len = 0;
465 	char *s, *e, *rp, *p, *rrp, *np, *cp, v;
466 	BUF_MEM *buf;
467 
468 	if ((buf = BUF_MEM_new()) == NULL)
469 		return (0);
470 
471 	len = strlen(from) + 1;
472 	if (!BUF_MEM_grow(buf, len))
473 		goto err;
474 
475 	for (;;) {
476 		if (IS_QUOTE(conf, *from)) {
477 			q = *from;
478 			from++;
479 			while (!IS_EOF(conf, *from) && (*from != q)) {
480 				if (IS_ESC(conf, *from)) {
481 					from++;
482 					if (IS_EOF(conf, *from))
483 						break;
484 				}
485 				buf->data[to++] = *(from++);
486 			}
487 			if (*from == q)
488 				from++;
489 		} else if (IS_DQUOTE(conf, *from)) {
490 			q = *from;
491 			from++;
492 			while (!IS_EOF(conf, *from)) {
493 				if (*from == q) {
494 					if (*(from + 1) == q) {
495 						from++;
496 					} else {
497 						break;
498 					}
499 				}
500 				buf->data[to++] = *(from++);
501 			}
502 			if (*from == q)
503 				from++;
504 		} else if (IS_ESC(conf, *from)) {
505 			from++;
506 			v = *(from++);
507 			if (IS_EOF(conf, v))
508 				break;
509 			else if (v == 'r')
510 				v = '\r';
511 			else if (v == 'n')
512 				v = '\n';
513 			else if (v == 'b')
514 				v = '\b';
515 			else if (v == 't')
516 				v = '\t';
517 			buf->data[to++] = v;
518 		} else if (IS_EOF(conf, *from))
519 			break;
520 		else if (*from == '$') {
521 			/* try to expand it */
522 			rrp = NULL;
523 			s = &(from[1]);
524 			if (*s == '{')
525 				q = '}';
526 			else if (*s == '(')
527 				q = ')';
528 			else
529 				q = 0;
530 
531 			if (q)
532 				s++;
533 			cp = section;
534 			e = np = s;
535 			while (IS_ALPHA_NUMERIC(conf, *e))
536 				e++;
537 			if ((e[0] == ':') && (e[1] == ':')) {
538 				cp = np;
539 				rrp = e;
540 				rr = *e;
541 				*rrp = '\0';
542 				e += 2;
543 				np = e;
544 				while (IS_ALPHA_NUMERIC(conf, *e))
545 					e++;
546 			}
547 			r = *e;
548 			*e = '\0';
549 			rp = e;
550 			if (q) {
551 				if (r != q) {
552 					CONFerr(CONF_F_STR_COPY,
553 					    CONF_R_NO_CLOSE_BRACE);
554 					goto err;
555 				}
556 				e++;
557 			}
558 			/* So at this point we have
559 			 * np which is the start of the name string which is
560 			 *   '\0' terminated.
561 			 * cp which is the start of the section string which is
562 			 *   '\0' terminated.
563 			 * e is the 'next point after'.
564 			 * r and rr are the chars replaced by the '\0'
565 			 * rp and rrp is where 'r' and 'rr' came from.
566 			 */
567 			p = _CONF_get_string(conf, cp, np);
568 			if (rrp != NULL)
569 				*rrp = rr;
570 			*rp = r;
571 			if (p == NULL) {
572 				CONFerr(CONF_F_STR_COPY,
573 				    CONF_R_VARIABLE_HAS_NO_VALUE);
574 				goto err;
575 			}
576 			if (!BUF_MEM_grow_clean(buf,
577 				(strlen(p) + buf->length - (e - from)))) {
578 				CONFerr(CONF_F_STR_COPY,
579 				    CONF_R_MODULE_INITIALIZATION_ERROR);
580 				goto err;
581 			}
582 			while (*p)
583 				buf->data[to++] = *(p++);
584 
585 			/* Since we change the pointer 'from', we also have
586 			   to change the perceived length of the string it
587 			   points at.  /RL */
588 			len -= e - from;
589 			from = e;
590 
591 			/* In case there were no braces or parenthesis around
592 			   the variable reference, we have to put back the
593 			   character that was replaced with a '\0'.  /RL */
594 			*rp = r;
595 		} else
596 			buf->data[to++] = *(from++);
597 	}
598 	buf->data[to]='\0';
599 	free(*pto);
600 	*pto = buf->data;
601 	free(buf);
602 	return (1);
603 
604 err:
605 	if (buf != NULL)
606 		BUF_MEM_free(buf);
607 	return (0);
608 }
609 
610 static char *
611 eat_ws(CONF *conf, char *p)
612 {
613 	while (IS_WS(conf, *p) && (!IS_EOF(conf, *p)))
614 		p++;
615 	return (p);
616 }
617 
618 static char *
619 eat_alpha_numeric(CONF *conf, char *p)
620 {
621 	for (;;) {
622 		if (IS_ESC(conf, *p)) {
623 			p = scan_esc(conf, p);
624 			continue;
625 		}
626 		if (!IS_ALPHA_NUMERIC_PUNCT(conf, *p))
627 			return (p);
628 		p++;
629 	}
630 }
631 
632 static char *
633 scan_quote(CONF *conf, char *p)
634 {
635 	int q = *p;
636 
637 	p++;
638 	while (!(IS_EOF(conf, *p)) && (*p != q)) {
639 		if (IS_ESC(conf, *p)) {
640 			p++;
641 			if (IS_EOF(conf, *p))
642 				return (p);
643 		}
644 		p++;
645 	}
646 	if (*p == q)
647 		p++;
648 	return (p);
649 }
650 
651 
652 static char *
653 scan_dquote(CONF *conf, char *p)
654 {
655 	int q = *p;
656 
657 	p++;
658 	while (!(IS_EOF(conf, *p))) {
659 		if (*p == q) {
660 			if (*(p + 1) == q) {
661 				p++;
662 			} else {
663 				break;
664 			}
665 		}
666 		p++;
667 	}
668 	if (*p == q)
669 		p++;
670 	return (p);
671 }
672 
673 static void
674 dump_value_doall_arg(CONF_VALUE *a, BIO *out)
675 {
676 	if (a->name)
677 		BIO_printf(out, "[%s] %s=%s\n", a->section, a->name, a->value);
678 	else
679 		BIO_printf(out, "[[%s]]\n", a->section);
680 }
681 
682 static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE, BIO)
683 
684 static int
685 def_dump(const CONF *conf, BIO *out)
686 {
687 	lh_CONF_VALUE_doall_arg(conf->data, LHASH_DOALL_ARG_FN(dump_value),
688 	    BIO, out);
689 	return 1;
690 }
691 
692 static int
693 def_is_number(const CONF *conf, char c)
694 {
695 	return IS_NUMBER(conf, c);
696 }
697 
698 static int
699 def_to_int(const CONF *conf, char c)
700 {
701 	return c - '0';
702 }
703