/src/openssl/crypto/conf/conf_def.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved. |
3 | | * |
4 | | * Licensed under the Apache License 2.0 (the "License"). You may not use |
5 | | * this file except in compliance with the License. You can obtain a copy |
6 | | * in the file LICENSE in the source distribution or at |
7 | | * https://www.openssl.org/source/license.html |
8 | | */ |
9 | | |
10 | | /* Part of the code in here was originally in conf.c, which is now removed */ |
11 | | |
12 | | #include <stdio.h> |
13 | | #include <string.h> |
14 | | #include "internal/e_os.h" /* struct stat */ |
15 | | #ifdef __TANDEM |
16 | | # include <sys/types.h> /* needed for stat.h */ |
17 | | # include <sys/stat.h> /* struct stat */ |
18 | | #endif |
19 | | #include "internal/cryptlib.h" |
20 | | #include "internal/o_dir.h" |
21 | | #include <openssl/lhash.h> |
22 | | #include <openssl/conf.h> |
23 | | #include <openssl/conf_api.h> |
24 | | #include "conf_local.h" |
25 | | #include "conf_def.h" |
26 | | #include <openssl/buffer.h> |
27 | | #include <openssl/err.h> |
28 | | #ifndef OPENSSL_NO_POSIX_IO |
29 | | # include <sys/stat.h> |
30 | | # ifdef _WIN32 |
31 | | # define stat _stat |
32 | | # endif |
33 | | #endif |
34 | | |
35 | | #ifndef S_ISDIR |
36 | | # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR) |
37 | | #endif |
38 | | |
39 | | /* |
40 | | * The maximum length we can grow a value to after variable expansion. 64k |
41 | | * should be more than enough for all reasonable uses. |
42 | | */ |
43 | 0 | #define MAX_CONF_VALUE_LENGTH 65536 |
44 | | |
45 | | static int is_keytype(const CONF *conf, char c, unsigned short type); |
46 | | static char *eat_ws(CONF *conf, char *p); |
47 | | static void trim_ws(CONF *conf, char *start); |
48 | | static char *eat_alpha_numeric(CONF *conf, char *p); |
49 | | static void clear_comments(CONF *conf, char *p); |
50 | | static int str_copy(CONF *conf, char *section, char **to, char *from); |
51 | | static char *scan_quote(CONF *conf, char *p); |
52 | | static char *scan_dquote(CONF *conf, char *p); |
53 | 0 | #define scan_esc(conf,p) (((IS_EOF((conf),(p)[1]))?((p)+1):((p)+2))) |
54 | | #ifndef OPENSSL_NO_POSIX_IO |
55 | | static BIO *process_include(char *include, OPENSSL_DIR_CTX **dirctx, |
56 | | char **dirpath); |
57 | | static BIO *get_next_file(const char *path, OPENSSL_DIR_CTX **dirctx); |
58 | | #endif |
59 | | |
60 | | static CONF *def_create(CONF_METHOD *meth); |
61 | | static int def_init_default(CONF *conf); |
62 | | #ifndef OPENSSL_NO_DEPRECATED_3_0 |
63 | | static int def_init_WIN32(CONF *conf); |
64 | | #endif |
65 | | static int def_destroy(CONF *conf); |
66 | | static int def_destroy_data(CONF *conf); |
67 | | static int def_load(CONF *conf, const char *name, long *eline); |
68 | | static int def_load_bio(CONF *conf, BIO *bp, long *eline); |
69 | | static int def_dump(const CONF *conf, BIO *bp); |
70 | | static int def_is_number(const CONF *conf, char c); |
71 | | static int def_to_int(const CONF *conf, char c); |
72 | | |
73 | | static CONF_METHOD default_method = { |
74 | | "OpenSSL default", |
75 | | def_create, |
76 | | def_init_default, |
77 | | def_destroy, |
78 | | def_destroy_data, |
79 | | def_load_bio, |
80 | | def_dump, |
81 | | def_is_number, |
82 | | def_to_int, |
83 | | def_load |
84 | | }; |
85 | | |
86 | | CONF_METHOD *NCONF_default(void) |
87 | 1 | { |
88 | 1 | return &default_method; |
89 | 1 | } |
90 | | |
91 | | #ifndef OPENSSL_NO_DEPRECATED_3_0 |
92 | | static CONF_METHOD WIN32_method = { |
93 | | "WIN32", |
94 | | def_create, |
95 | | def_init_WIN32, |
96 | | def_destroy, |
97 | | def_destroy_data, |
98 | | def_load_bio, |
99 | | def_dump, |
100 | | def_is_number, |
101 | | def_to_int, |
102 | | def_load |
103 | | }; |
104 | | |
105 | | CONF_METHOD *NCONF_WIN32(void) |
106 | 0 | { |
107 | 0 | return &WIN32_method; |
108 | 0 | } |
109 | | #endif |
110 | | |
111 | | static CONF *def_create(CONF_METHOD *meth) |
112 | 1 | { |
113 | 1 | CONF *ret; |
114 | | |
115 | 1 | ret = OPENSSL_malloc(sizeof(*ret)); |
116 | 1 | if (ret != NULL) |
117 | 1 | if (meth->init(ret) == 0) { |
118 | 0 | OPENSSL_free(ret); |
119 | 0 | ret = NULL; |
120 | 0 | } |
121 | 1 | return ret; |
122 | 1 | } |
123 | | |
124 | | static int def_init_default(CONF *conf) |
125 | 1 | { |
126 | 1 | if (conf == NULL) |
127 | 0 | return 0; |
128 | | |
129 | 1 | memset(conf, 0, sizeof(*conf)); |
130 | 1 | conf->meth = &default_method; |
131 | 1 | conf->meth_data = (void *)CONF_type_default; |
132 | | |
133 | 1 | return 1; |
134 | 1 | } |
135 | | |
136 | | #ifndef OPENSSL_NO_DEPRECATED_3_0 |
137 | | static int def_init_WIN32(CONF *conf) |
138 | 0 | { |
139 | 0 | if (conf == NULL) |
140 | 0 | return 0; |
141 | | |
142 | 0 | memset(conf, 0, sizeof(*conf)); |
143 | 0 | conf->meth = &WIN32_method; |
144 | 0 | conf->meth_data = (void *)CONF_type_win32; |
145 | |
|
146 | 0 | return 1; |
147 | 0 | } |
148 | | #endif |
149 | | |
150 | | static int def_destroy(CONF *conf) |
151 | 1 | { |
152 | 1 | if (def_destroy_data(conf)) { |
153 | 1 | OPENSSL_free(conf); |
154 | 1 | return 1; |
155 | 1 | } |
156 | 0 | return 0; |
157 | 1 | } |
158 | | |
159 | | static int def_destroy_data(CONF *conf) |
160 | 1 | { |
161 | 1 | if (conf == NULL) |
162 | 0 | return 0; |
163 | 1 | _CONF_free_data(conf); |
164 | 1 | return 1; |
165 | 1 | } |
166 | | |
167 | | static int def_load(CONF *conf, const char *name, long *line) |
168 | 1 | { |
169 | 1 | int ret; |
170 | 1 | BIO *in = NULL; |
171 | | |
172 | | #ifdef OPENSSL_SYS_VMS |
173 | | in = BIO_new_file(name, "r"); |
174 | | #else |
175 | 1 | in = BIO_new_file(name, "rb"); |
176 | 1 | #endif |
177 | 1 | if (in == NULL) { |
178 | 1 | if (ERR_GET_REASON(ERR_peek_last_error()) == BIO_R_NO_SUCH_FILE) |
179 | 1 | ERR_raise(ERR_LIB_CONF, CONF_R_NO_SUCH_FILE); |
180 | 0 | else |
181 | 1 | ERR_raise(ERR_LIB_CONF, ERR_R_SYS_LIB); |
182 | 1 | return 0; |
183 | 1 | } |
184 | | |
185 | 0 | ret = def_load_bio(conf, in, line); |
186 | 0 | BIO_free(in); |
187 | |
|
188 | 0 | return ret; |
189 | 1 | } |
190 | | |
191 | | |
192 | | /* Parse a boolean value and fill in *flag. Return 0 on error. */ |
193 | | static int parsebool(const char *pval, int *flag) |
194 | 0 | { |
195 | 0 | if (OPENSSL_strcasecmp(pval, "on") == 0 |
196 | 0 | || OPENSSL_strcasecmp(pval, "true") == 0) { |
197 | 0 | *flag = 1; |
198 | 0 | } else if (OPENSSL_strcasecmp(pval, "off") == 0 |
199 | 0 | || OPENSSL_strcasecmp(pval, "false") == 0) { |
200 | 0 | *flag = 0; |
201 | 0 | } else { |
202 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_INVALID_PRAGMA); |
203 | 0 | return 0; |
204 | 0 | } |
205 | 0 | return 1; |
206 | 0 | } |
207 | | |
208 | | static int def_load_bio(CONF *conf, BIO *in, long *line) |
209 | 0 | { |
210 | | /* The macro BUFSIZE conflicts with a system macro in VxWorks */ |
211 | 0 | #define CONFBUFSIZE 512 |
212 | 0 | int bufnum = 0, i, ii; |
213 | 0 | BUF_MEM *buff = NULL; |
214 | 0 | char *s, *p, *end; |
215 | 0 | int again; |
216 | 0 | int first_call = 1; |
217 | 0 | long eline = 0; |
218 | 0 | char btmp[DECIMAL_SIZE(eline) + 1]; |
219 | 0 | CONF_VALUE *v = NULL, *tv; |
220 | 0 | CONF_VALUE *sv = NULL; |
221 | 0 | char *section = NULL, *buf; |
222 | 0 | char *start, *psection, *pname; |
223 | 0 | void *h = (void *)(conf->data); |
224 | 0 | STACK_OF(BIO) *biosk = NULL; |
225 | 0 | #ifndef OPENSSL_NO_POSIX_IO |
226 | 0 | char *dirpath = NULL; |
227 | 0 | OPENSSL_DIR_CTX *dirctx = NULL; |
228 | 0 | #endif |
229 | 0 | #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION |
230 | 0 | int numincludes = 0; |
231 | 0 | #endif |
232 | |
|
233 | 0 | if ((buff = BUF_MEM_new()) == NULL) { |
234 | 0 | ERR_raise(ERR_LIB_CONF, ERR_R_BUF_LIB); |
235 | 0 | goto err; |
236 | 0 | } |
237 | | |
238 | 0 | section = OPENSSL_strdup("default"); |
239 | 0 | if (section == NULL) |
240 | 0 | goto err; |
241 | | |
242 | 0 | if (_CONF_new_data(conf) == 0) { |
243 | 0 | ERR_raise(ERR_LIB_CONF, ERR_R_CONF_LIB); |
244 | 0 | goto err; |
245 | 0 | } |
246 | | |
247 | 0 | sv = _CONF_new_section(conf, section); |
248 | 0 | if (sv == NULL) { |
249 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_UNABLE_TO_CREATE_NEW_SECTION); |
250 | 0 | goto err; |
251 | 0 | } |
252 | | |
253 | 0 | bufnum = 0; |
254 | 0 | again = 0; |
255 | 0 | for (;;) { |
256 | 0 | if (!BUF_MEM_grow(buff, bufnum + CONFBUFSIZE)) { |
257 | 0 | ERR_raise(ERR_LIB_CONF, ERR_R_BUF_LIB); |
258 | 0 | goto err; |
259 | 0 | } |
260 | 0 | p = &(buff->data[bufnum]); |
261 | 0 | *p = '\0'; |
262 | 0 | read_retry: |
263 | 0 | if (in != NULL && BIO_gets(in, p, CONFBUFSIZE - 1) < 0) |
264 | 0 | goto err; |
265 | 0 | p[CONFBUFSIZE - 1] = '\0'; |
266 | 0 | ii = i = strlen(p); |
267 | 0 | if (first_call) { |
268 | | /* Other BOMs imply unsupported multibyte encoding, |
269 | | * so don't strip them and let the error raise */ |
270 | 0 | const unsigned char utf8_bom[3] = {0xEF, 0xBB, 0xBF}; |
271 | |
|
272 | 0 | if (i >= 3 && memcmp(p, utf8_bom, 3) == 0) { |
273 | 0 | memmove(p, p + 3, i - 3); |
274 | 0 | p[i - 3] = 0; |
275 | 0 | i -= 3; |
276 | 0 | ii -= 3; |
277 | 0 | } |
278 | 0 | first_call = 0; |
279 | 0 | } |
280 | 0 | if (i == 0 && !again) { |
281 | | /* the currently processed BIO is NULL or at EOF */ |
282 | 0 | BIO *parent; |
283 | |
|
284 | 0 | #ifndef OPENSSL_NO_POSIX_IO |
285 | | /* continue processing with the next file from directory */ |
286 | 0 | if (dirctx != NULL) { |
287 | 0 | BIO *next; |
288 | |
|
289 | 0 | if ((next = get_next_file(dirpath, &dirctx)) != NULL) { |
290 | 0 | BIO_vfree(in); |
291 | 0 | in = next; |
292 | 0 | goto read_retry; |
293 | 0 | } else { |
294 | 0 | OPENSSL_free(dirpath); |
295 | 0 | dirpath = NULL; |
296 | 0 | } |
297 | 0 | } |
298 | 0 | #endif |
299 | | /* no more files in directory, continue with processing parent */ |
300 | 0 | if ((parent = sk_BIO_pop(biosk)) == NULL) { |
301 | | /* everything processed get out of the loop */ |
302 | 0 | break; |
303 | 0 | } else { |
304 | 0 | BIO_vfree(in); |
305 | 0 | in = parent; |
306 | 0 | goto read_retry; |
307 | 0 | } |
308 | 0 | } |
309 | 0 | again = 0; |
310 | 0 | while (i > 0) { |
311 | 0 | if ((p[i - 1] != '\r') && (p[i - 1] != '\n')) |
312 | 0 | break; |
313 | 0 | else |
314 | 0 | i--; |
315 | 0 | } |
316 | | /* |
317 | | * we removed some trailing stuff so there is a new line on the end. |
318 | | */ |
319 | 0 | if (ii && i == ii) |
320 | 0 | again = 1; /* long line */ |
321 | 0 | else { |
322 | 0 | p[i] = '\0'; |
323 | 0 | eline++; /* another input line */ |
324 | 0 | } |
325 | | |
326 | | /* we now have a line with trailing \r\n removed */ |
327 | | |
328 | | /* i is the number of bytes */ |
329 | 0 | bufnum += i; |
330 | |
|
331 | 0 | v = NULL; |
332 | | /* check for line continuation */ |
333 | 0 | if (bufnum >= 1) { |
334 | | /* |
335 | | * If we have bytes and the last char '\\' and second last char |
336 | | * is not '\\' |
337 | | */ |
338 | 0 | p = &(buff->data[bufnum - 1]); |
339 | 0 | if (IS_ESC(conf, p[0]) && ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) { |
340 | 0 | bufnum--; |
341 | 0 | again = 1; |
342 | 0 | } |
343 | 0 | } |
344 | 0 | if (again) |
345 | 0 | continue; |
346 | 0 | bufnum = 0; |
347 | 0 | buf = buff->data; |
348 | |
|
349 | 0 | clear_comments(conf, buf); |
350 | 0 | s = eat_ws(conf, buf); |
351 | 0 | if (IS_EOF(conf, *s)) |
352 | 0 | continue; /* blank line */ |
353 | 0 | if (*s == '[') { |
354 | 0 | char *ss; |
355 | |
|
356 | 0 | s++; |
357 | 0 | start = eat_ws(conf, s); |
358 | 0 | ss = start; |
359 | 0 | again: |
360 | 0 | end = eat_alpha_numeric(conf, ss); |
361 | 0 | p = eat_ws(conf, end); |
362 | 0 | if (*p != ']') { |
363 | 0 | if (*p != '\0' && ss != p) { |
364 | 0 | ss = p; |
365 | 0 | goto again; |
366 | 0 | } |
367 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_MISSING_CLOSE_SQUARE_BRACKET); |
368 | 0 | goto err; |
369 | 0 | } |
370 | 0 | *end = '\0'; |
371 | 0 | if (!str_copy(conf, NULL, §ion, start)) |
372 | 0 | goto err; |
373 | 0 | if ((sv = _CONF_get_section(conf, section)) == NULL) |
374 | 0 | sv = _CONF_new_section(conf, section); |
375 | 0 | if (sv == NULL) { |
376 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_UNABLE_TO_CREATE_NEW_SECTION); |
377 | 0 | goto err; |
378 | 0 | } |
379 | 0 | continue; |
380 | 0 | } else { |
381 | 0 | pname = s; |
382 | 0 | end = eat_alpha_numeric(conf, s); |
383 | 0 | if ((end[0] == ':') && (end[1] == ':')) { |
384 | 0 | *end = '\0'; |
385 | 0 | end += 2; |
386 | 0 | psection = pname; |
387 | 0 | pname = end; |
388 | 0 | end = eat_alpha_numeric(conf, end); |
389 | 0 | } else { |
390 | 0 | psection = section; |
391 | 0 | } |
392 | 0 | p = eat_ws(conf, end); |
393 | 0 | if (CHECK_AND_SKIP_PREFIX(pname, ".pragma") |
394 | 0 | && (p != pname || *p == '=')) { |
395 | 0 | char *pval; |
396 | |
|
397 | 0 | if (*p == '=') { |
398 | 0 | p++; |
399 | 0 | p = eat_ws(conf, p); |
400 | 0 | } |
401 | 0 | trim_ws(conf, p); |
402 | | |
403 | | /* Pragma values take the form keyword:value */ |
404 | 0 | pval = strchr(p, ':'); |
405 | 0 | if (pval == NULL || pval == p || pval[1] == '\0') { |
406 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_INVALID_PRAGMA); |
407 | 0 | goto err; |
408 | 0 | } |
409 | | |
410 | 0 | *pval++ = '\0'; |
411 | 0 | trim_ws(conf, p); |
412 | 0 | pval = eat_ws(conf, pval); |
413 | | |
414 | | /* |
415 | | * Known pragmas: |
416 | | * |
417 | | * dollarid takes "on", "true or "off", "false" |
418 | | * abspath takes "on", "true or "off", "false" |
419 | | * includedir directory prefix |
420 | | */ |
421 | 0 | if (strcmp(p, "dollarid") == 0) { |
422 | 0 | if (!parsebool(pval, &conf->flag_dollarid)) |
423 | 0 | goto err; |
424 | 0 | } else if (strcmp(p, "abspath") == 0) { |
425 | 0 | if (!parsebool(pval, &conf->flag_abspath)) |
426 | 0 | goto err; |
427 | 0 | } else if (strcmp(p, "includedir") == 0) { |
428 | 0 | OPENSSL_free(conf->includedir); |
429 | 0 | if ((conf->includedir = OPENSSL_strdup(pval)) == NULL) |
430 | 0 | goto err; |
431 | 0 | } |
432 | | |
433 | | /* |
434 | | * We *ignore* any unknown pragma. |
435 | | */ |
436 | 0 | continue; |
437 | 0 | } else if (CHECK_AND_SKIP_PREFIX(pname, ".include") |
438 | 0 | && (p != pname || *p == '=')) { |
439 | 0 | char *include = NULL; |
440 | 0 | BIO *next; |
441 | 0 | const char *include_dir = ossl_safe_getenv("OPENSSL_CONF_INCLUDE"); |
442 | 0 | char *include_path = NULL; |
443 | |
|
444 | 0 | #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION |
445 | | /* |
446 | | * The include processing below can cause the "conf" fuzzer to |
447 | | * timeout due to the fuzzer inserting large and complicated |
448 | | * includes - with a large amount of time spent in |
449 | | * OPENSSL_strlcat/OPENSSL_strcpy. This is not a security |
450 | | * concern because config files should never come from untrusted |
451 | | * sources. We just set an arbitrary limit on the allowed |
452 | | * number of includes when fuzzing to prevent this timeout. |
453 | | */ |
454 | 0 | if (numincludes++ > 10) |
455 | 0 | goto err; |
456 | 0 | #endif |
457 | | |
458 | 0 | if (include_dir == NULL) |
459 | 0 | include_dir = conf->includedir; |
460 | |
|
461 | 0 | if (*p == '=') { |
462 | 0 | p++; |
463 | 0 | p = eat_ws(conf, p); |
464 | 0 | } |
465 | 0 | trim_ws(conf, p); |
466 | 0 | if (!str_copy(conf, psection, &include, p)) |
467 | 0 | goto err; |
468 | | |
469 | 0 | if (include_dir != NULL && !ossl_is_absolute_path(include)) { |
470 | 0 | size_t newlen = strlen(include_dir) + strlen(include) + 2; |
471 | |
|
472 | 0 | include_path = OPENSSL_malloc(newlen); |
473 | 0 | if (include_path == NULL) { |
474 | 0 | OPENSSL_free(include); |
475 | 0 | goto err; |
476 | 0 | } |
477 | | |
478 | 0 | OPENSSL_strlcpy(include_path, include_dir, newlen); |
479 | 0 | if (!ossl_ends_with_dirsep(include_path)) |
480 | 0 | OPENSSL_strlcat(include_path, "/", newlen); |
481 | 0 | OPENSSL_strlcat(include_path, include, newlen); |
482 | 0 | OPENSSL_free(include); |
483 | 0 | } else { |
484 | 0 | include_path = include; |
485 | 0 | } |
486 | | |
487 | 0 | if (conf->flag_abspath |
488 | 0 | && !ossl_is_absolute_path(include_path)) { |
489 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_RELATIVE_PATH); |
490 | 0 | OPENSSL_free(include_path); |
491 | 0 | goto err; |
492 | 0 | } |
493 | | |
494 | | /* get the BIO of the included file */ |
495 | 0 | #ifndef OPENSSL_NO_POSIX_IO |
496 | 0 | next = process_include(include_path, &dirctx, &dirpath); |
497 | 0 | if (include_path != dirpath) { |
498 | | /* dirpath will contain include in case of a directory */ |
499 | 0 | OPENSSL_free(include_path); |
500 | 0 | } |
501 | | #else |
502 | | next = BIO_new_file(include_path, "r"); |
503 | | OPENSSL_free(include_path); |
504 | | #endif |
505 | |
|
506 | 0 | if (next != NULL) { |
507 | | /* push the currently processing BIO onto stack */ |
508 | 0 | if (biosk == NULL) { |
509 | 0 | if ((biosk = sk_BIO_new_null()) == NULL) { |
510 | 0 | ERR_raise(ERR_LIB_CONF, ERR_R_CRYPTO_LIB); |
511 | 0 | BIO_free(next); |
512 | 0 | goto err; |
513 | 0 | } |
514 | 0 | } |
515 | 0 | if (!sk_BIO_push(biosk, in)) { |
516 | 0 | ERR_raise(ERR_LIB_CONF, ERR_R_CRYPTO_LIB); |
517 | 0 | BIO_free(next); |
518 | 0 | goto err; |
519 | 0 | } |
520 | | /* continue with reading from the included BIO */ |
521 | 0 | in = next; |
522 | 0 | } |
523 | 0 | continue; |
524 | 0 | } else if (*p != '=') { |
525 | 0 | ERR_raise_data(ERR_LIB_CONF, CONF_R_MISSING_EQUAL_SIGN, |
526 | 0 | "HERE-->%s", p); |
527 | 0 | goto err; |
528 | 0 | } |
529 | 0 | *end = '\0'; |
530 | 0 | p++; |
531 | 0 | start = eat_ws(conf, p); |
532 | 0 | trim_ws(conf, start); |
533 | |
|
534 | 0 | if ((v = OPENSSL_malloc(sizeof(*v))) == NULL) |
535 | 0 | goto err; |
536 | 0 | v->name = OPENSSL_strdup(pname); |
537 | 0 | v->value = NULL; |
538 | 0 | if (v->name == NULL) |
539 | 0 | goto err; |
540 | 0 | if (!str_copy(conf, psection, &(v->value), start)) |
541 | 0 | goto err; |
542 | | |
543 | 0 | if (strcmp(psection, section) != 0) { |
544 | 0 | if ((tv = _CONF_get_section(conf, psection)) |
545 | 0 | == NULL) |
546 | 0 | tv = _CONF_new_section(conf, psection); |
547 | 0 | if (tv == NULL) { |
548 | 0 | ERR_raise(ERR_LIB_CONF, |
549 | 0 | CONF_R_UNABLE_TO_CREATE_NEW_SECTION); |
550 | 0 | goto err; |
551 | 0 | } |
552 | 0 | } else |
553 | 0 | tv = sv; |
554 | 0 | if (_CONF_add_string(conf, tv, v) == 0) { |
555 | 0 | ERR_raise(ERR_LIB_CONF, ERR_R_CONF_LIB); |
556 | 0 | goto err; |
557 | 0 | } |
558 | 0 | v = NULL; |
559 | 0 | } |
560 | 0 | } |
561 | 0 | BUF_MEM_free(buff); |
562 | 0 | OPENSSL_free(section); |
563 | | /* |
564 | | * No need to pop, since we only get here if the stack is empty. |
565 | | * If this causes a BIO leak, THE ISSUE IS SOMEWHERE ELSE! |
566 | | */ |
567 | 0 | sk_BIO_free(biosk); |
568 | 0 | return 1; |
569 | | |
570 | 0 | err: |
571 | 0 | BUF_MEM_free(buff); |
572 | 0 | OPENSSL_free(section); |
573 | | /* |
574 | | * Since |in| is the first element of the stack and should NOT be freed |
575 | | * here, we cannot use sk_BIO_pop_free(). Instead, we pop and free one |
576 | | * BIO at a time, making sure that the last one popped isn't. |
577 | | */ |
578 | 0 | while (sk_BIO_num(biosk) > 0) { |
579 | 0 | BIO *popped = sk_BIO_pop(biosk); |
580 | 0 | BIO_vfree(in); |
581 | 0 | in = popped; |
582 | 0 | } |
583 | 0 | sk_BIO_free(biosk); |
584 | 0 | #ifndef OPENSSL_NO_POSIX_IO |
585 | 0 | OPENSSL_free(dirpath); |
586 | 0 | if (dirctx != NULL) |
587 | 0 | OPENSSL_DIR_end(&dirctx); |
588 | 0 | #endif |
589 | 0 | if (line != NULL) |
590 | 0 | *line = eline; |
591 | 0 | BIO_snprintf(btmp, sizeof(btmp), "%ld", eline); |
592 | 0 | ERR_add_error_data(2, "line ", btmp); |
593 | 0 | if (h != conf->data) { |
594 | 0 | CONF_free(conf->data); |
595 | 0 | conf->data = NULL; |
596 | 0 | } |
597 | 0 | if (v != NULL) { |
598 | 0 | OPENSSL_free(v->name); |
599 | 0 | OPENSSL_free(v->value); |
600 | 0 | OPENSSL_free(v); |
601 | 0 | } |
602 | 0 | return 0; |
603 | 0 | } |
604 | | |
605 | | static void clear_comments(CONF *conf, char *p) |
606 | 0 | { |
607 | 0 | for (;;) { |
608 | 0 | if (IS_FCOMMENT(conf, *p)) { |
609 | 0 | *p = '\0'; |
610 | 0 | return; |
611 | 0 | } |
612 | 0 | if (!IS_WS(conf, *p)) { |
613 | 0 | break; |
614 | 0 | } |
615 | 0 | p++; |
616 | 0 | } |
617 | | |
618 | 0 | for (;;) { |
619 | 0 | if (IS_COMMENT(conf, *p)) { |
620 | 0 | *p = '\0'; |
621 | 0 | return; |
622 | 0 | } |
623 | 0 | if (IS_DQUOTE(conf, *p)) { |
624 | 0 | p = scan_dquote(conf, p); |
625 | 0 | continue; |
626 | 0 | } |
627 | 0 | if (IS_QUOTE(conf, *p)) { |
628 | 0 | p = scan_quote(conf, p); |
629 | 0 | continue; |
630 | 0 | } |
631 | 0 | if (IS_ESC(conf, *p)) { |
632 | 0 | p = scan_esc(conf, p); |
633 | 0 | continue; |
634 | 0 | } |
635 | 0 | if (IS_EOF(conf, *p)) |
636 | 0 | return; |
637 | 0 | else |
638 | 0 | p++; |
639 | 0 | } |
640 | 0 | } |
641 | | |
642 | | static int str_copy(CONF *conf, char *section, char **pto, char *from) |
643 | 0 | { |
644 | 0 | int q, r, rr = 0, to = 0, len = 0; |
645 | 0 | char *s, *e, *rp, *p, *rrp, *np, *cp, v; |
646 | 0 | BUF_MEM *buf; |
647 | |
|
648 | 0 | if ((buf = BUF_MEM_new()) == NULL) |
649 | 0 | return 0; |
650 | | |
651 | 0 | len = strlen(from) + 1; |
652 | 0 | if (!BUF_MEM_grow(buf, len)) |
653 | 0 | goto err; |
654 | | |
655 | 0 | for (;;) { |
656 | 0 | if (IS_QUOTE(conf, *from)) { |
657 | 0 | q = *from; |
658 | 0 | from++; |
659 | 0 | while (!IS_EOF(conf, *from) && (*from != q)) { |
660 | 0 | if (IS_ESC(conf, *from)) { |
661 | 0 | from++; |
662 | 0 | if (IS_EOF(conf, *from)) |
663 | 0 | break; |
664 | 0 | } |
665 | 0 | buf->data[to++] = *(from++); |
666 | 0 | } |
667 | 0 | if (*from == q) |
668 | 0 | from++; |
669 | 0 | } else if (IS_DQUOTE(conf, *from)) { |
670 | 0 | q = *from; |
671 | 0 | from++; |
672 | 0 | while (!IS_EOF(conf, *from)) { |
673 | 0 | if (*from == q) { |
674 | 0 | if (*(from + 1) == q) { |
675 | 0 | from++; |
676 | 0 | } else { |
677 | 0 | break; |
678 | 0 | } |
679 | 0 | } |
680 | 0 | buf->data[to++] = *(from++); |
681 | 0 | } |
682 | 0 | if (*from == q) |
683 | 0 | from++; |
684 | 0 | } else if (IS_ESC(conf, *from)) { |
685 | 0 | from++; |
686 | 0 | v = *(from++); |
687 | 0 | if (IS_EOF(conf, v)) |
688 | 0 | break; |
689 | 0 | else if (v == 'r') |
690 | 0 | v = '\r'; |
691 | 0 | else if (v == 'n') |
692 | 0 | v = '\n'; |
693 | 0 | else if (v == 'b') |
694 | 0 | v = '\b'; |
695 | 0 | else if (v == 't') |
696 | 0 | v = '\t'; |
697 | 0 | buf->data[to++] = v; |
698 | 0 | } else if (IS_EOF(conf, *from)) |
699 | 0 | break; |
700 | 0 | else if (*from == '$' |
701 | 0 | && (!conf->flag_dollarid |
702 | 0 | || from[1] == '{' |
703 | 0 | || from[1] == '(')) { |
704 | 0 | size_t newsize; |
705 | | |
706 | | /* try to expand it */ |
707 | 0 | rrp = NULL; |
708 | 0 | s = &(from[1]); |
709 | 0 | if (*s == '{') |
710 | 0 | q = '}'; |
711 | 0 | else if (*s == '(') |
712 | 0 | q = ')'; |
713 | 0 | else |
714 | 0 | q = 0; |
715 | |
|
716 | 0 | if (q) |
717 | 0 | s++; |
718 | 0 | cp = section; |
719 | 0 | e = np = s; |
720 | 0 | while (IS_ALNUM(conf, *e) |
721 | 0 | || (conf->flag_dollarid && IS_DOLLAR(conf, *e))) |
722 | 0 | e++; |
723 | 0 | if ((e[0] == ':') && (e[1] == ':')) { |
724 | 0 | cp = np; |
725 | 0 | rrp = e; |
726 | 0 | rr = *e; |
727 | 0 | *rrp = '\0'; |
728 | 0 | e += 2; |
729 | 0 | np = e; |
730 | 0 | while (IS_ALNUM(conf, *e) |
731 | 0 | || (conf->flag_dollarid && IS_DOLLAR(conf, *e))) |
732 | 0 | e++; |
733 | 0 | } |
734 | 0 | r = *e; |
735 | 0 | *e = '\0'; |
736 | 0 | rp = e; |
737 | 0 | if (q) { |
738 | 0 | if (r != q) { |
739 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_NO_CLOSE_BRACE); |
740 | 0 | goto err; |
741 | 0 | } |
742 | 0 | e++; |
743 | 0 | } |
744 | | /*- |
745 | | * So at this point we have |
746 | | * np which is the start of the name string which is |
747 | | * '\0' terminated. |
748 | | * cp which is the start of the section string which is |
749 | | * '\0' terminated. |
750 | | * e is the 'next point after'. |
751 | | * r and rr are the chars replaced by the '\0' |
752 | | * rp and rrp is where 'r' and 'rr' came from. |
753 | | */ |
754 | 0 | p = _CONF_get_string(conf, cp, np); |
755 | 0 | if (rrp != NULL) |
756 | 0 | *rrp = rr; |
757 | 0 | *rp = r; |
758 | 0 | if (p == NULL) { |
759 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_VARIABLE_HAS_NO_VALUE); |
760 | 0 | goto err; |
761 | 0 | } |
762 | 0 | newsize = strlen(p) + buf->length - (e - from); |
763 | 0 | if (newsize > MAX_CONF_VALUE_LENGTH) { |
764 | 0 | ERR_raise(ERR_LIB_CONF, CONF_R_VARIABLE_EXPANSION_TOO_LONG); |
765 | 0 | goto err; |
766 | 0 | } |
767 | 0 | if (!BUF_MEM_grow_clean(buf, newsize)) { |
768 | 0 | ERR_raise(ERR_LIB_CONF, ERR_R_BUF_LIB); |
769 | 0 | goto err; |
770 | 0 | } |
771 | 0 | while (*p) |
772 | 0 | buf->data[to++] = *(p++); |
773 | | |
774 | | /* |
775 | | * Since we change the pointer 'from', we also have to change the |
776 | | * perceived length of the string it points at. /RL |
777 | | */ |
778 | 0 | len -= e - from; |
779 | 0 | from = e; |
780 | | |
781 | | /* |
782 | | * In case there were no braces or parenthesis around the |
783 | | * variable reference, we have to put back the character that was |
784 | | * replaced with a '\0'. /RL |
785 | | */ |
786 | 0 | *rp = r; |
787 | 0 | } else |
788 | 0 | buf->data[to++] = *(from++); |
789 | 0 | } |
790 | 0 | buf->data[to] = '\0'; |
791 | 0 | OPENSSL_free(*pto); |
792 | 0 | *pto = buf->data; |
793 | 0 | OPENSSL_free(buf); |
794 | 0 | return 1; |
795 | 0 | err: |
796 | 0 | BUF_MEM_free(buf); |
797 | 0 | return 0; |
798 | 0 | } |
799 | | |
800 | | #ifndef OPENSSL_NO_POSIX_IO |
801 | | /* |
802 | | * Check whether included path is a directory. |
803 | | * Returns next BIO to process and in case of a directory |
804 | | * also an opened directory context and the include path. |
805 | | */ |
806 | | static BIO *process_include(char *include, OPENSSL_DIR_CTX **dirctx, |
807 | | char **dirpath) |
808 | 0 | { |
809 | 0 | struct stat st; |
810 | 0 | BIO *next; |
811 | |
|
812 | 0 | if (stat(include, &st) < 0) { |
813 | 0 | ERR_raise_data(ERR_LIB_SYS, errno, "calling stat(%s)", include); |
814 | | /* missing include file is not fatal error */ |
815 | 0 | return NULL; |
816 | 0 | } |
817 | | |
818 | 0 | if (S_ISDIR(st.st_mode)) { |
819 | 0 | if (*dirctx != NULL) { |
820 | 0 | ERR_raise_data(ERR_LIB_CONF, CONF_R_RECURSIVE_DIRECTORY_INCLUDE, |
821 | 0 | "%s", include); |
822 | 0 | return NULL; |
823 | 0 | } |
824 | | /* a directory, load its contents */ |
825 | 0 | if ((next = get_next_file(include, dirctx)) != NULL) |
826 | 0 | *dirpath = include; |
827 | 0 | return next; |
828 | 0 | } |
829 | | |
830 | 0 | next = BIO_new_file(include, "r"); |
831 | 0 | return next; |
832 | 0 | } |
833 | | |
834 | | /* |
835 | | * Get next file from the directory path. |
836 | | * Returns BIO of the next file to read and updates dirctx. |
837 | | */ |
838 | | static BIO *get_next_file(const char *path, OPENSSL_DIR_CTX **dirctx) |
839 | 0 | { |
840 | 0 | const char *filename; |
841 | 0 | size_t pathlen; |
842 | |
|
843 | 0 | pathlen = strlen(path); |
844 | 0 | while ((filename = OPENSSL_DIR_read(dirctx, path)) != NULL) { |
845 | 0 | size_t namelen; |
846 | |
|
847 | 0 | namelen = strlen(filename); |
848 | | |
849 | |
|
850 | 0 | if ((namelen > 5 |
851 | 0 | && OPENSSL_strcasecmp(filename + namelen - 5, ".conf") == 0) |
852 | 0 | || (namelen > 4 |
853 | 0 | && OPENSSL_strcasecmp(filename + namelen - 4, ".cnf") == 0)) { |
854 | 0 | size_t newlen; |
855 | 0 | char *newpath; |
856 | 0 | BIO *bio; |
857 | |
|
858 | 0 | newlen = pathlen + namelen + 2; |
859 | 0 | newpath = OPENSSL_zalloc(newlen); |
860 | 0 | if (newpath == NULL) |
861 | 0 | break; |
862 | | #ifdef OPENSSL_SYS_VMS |
863 | | /* |
864 | | * If the given path isn't clear VMS syntax, |
865 | | * we treat it as on Unix. |
866 | | */ |
867 | | if (path[pathlen - 1] == ']' |
868 | | || path[pathlen - 1] == '>' |
869 | | || path[pathlen - 1] == ':') { |
870 | | /* Clear VMS directory syntax, just copy as is */ |
871 | | OPENSSL_strlcpy(newpath, path, newlen); |
872 | | } |
873 | | #endif |
874 | 0 | if (newpath[0] == '\0') { |
875 | 0 | OPENSSL_strlcpy(newpath, path, newlen); |
876 | 0 | OPENSSL_strlcat(newpath, "/", newlen); |
877 | 0 | } |
878 | 0 | OPENSSL_strlcat(newpath, filename, newlen); |
879 | |
|
880 | 0 | bio = BIO_new_file(newpath, "r"); |
881 | 0 | OPENSSL_free(newpath); |
882 | | /* Errors when opening files are non-fatal. */ |
883 | 0 | if (bio != NULL) |
884 | 0 | return bio; |
885 | 0 | } |
886 | 0 | } |
887 | 0 | OPENSSL_DIR_end(dirctx); |
888 | 0 | *dirctx = NULL; |
889 | 0 | return NULL; |
890 | 0 | } |
891 | | #endif |
892 | | |
893 | | static int is_keytype(const CONF *conf, char c, unsigned short type) |
894 | 0 | { |
895 | 0 | const unsigned short * keytypes = (const unsigned short *) conf->meth_data; |
896 | 0 | unsigned char key = (unsigned char)c; |
897 | |
|
898 | | #ifdef CHARSET_EBCDIC |
899 | | # if CHAR_BIT > 8 |
900 | | if (key > 255) { |
901 | | /* key is out of range for os_toascii table */ |
902 | | return 0; |
903 | | } |
904 | | # endif |
905 | | /* convert key from ebcdic to ascii */ |
906 | | key = os_toascii[key]; |
907 | | #endif |
908 | |
|
909 | 0 | if (key > 127) { |
910 | | /* key is not a seven bit ascii character */ |
911 | 0 | return 0; |
912 | 0 | } |
913 | | |
914 | 0 | return (keytypes[key] & type) ? 1 : 0; |
915 | 0 | } |
916 | | |
917 | | static char *eat_ws(CONF *conf, char *p) |
918 | 0 | { |
919 | 0 | while (IS_WS(conf, *p) && (!IS_EOF(conf, *p))) |
920 | 0 | p++; |
921 | 0 | return p; |
922 | 0 | } |
923 | | |
924 | | static void trim_ws(CONF *conf, char *start) |
925 | 0 | { |
926 | 0 | char *p = start; |
927 | |
|
928 | 0 | while (!IS_EOF(conf, *p)) |
929 | 0 | p++; |
930 | 0 | p--; |
931 | 0 | while ((p >= start) && IS_WS(conf, *p)) |
932 | 0 | p--; |
933 | 0 | p++; |
934 | 0 | *p = '\0'; |
935 | 0 | } |
936 | | |
937 | | static char *eat_alpha_numeric(CONF *conf, char *p) |
938 | 0 | { |
939 | 0 | for (;;) { |
940 | 0 | if (IS_ESC(conf, *p)) { |
941 | 0 | p = scan_esc(conf, p); |
942 | 0 | continue; |
943 | 0 | } |
944 | 0 | if (!(IS_ALNUM_PUNCT(conf, *p) |
945 | 0 | || (conf->flag_dollarid && IS_DOLLAR(conf, *p)))) |
946 | 0 | return p; |
947 | 0 | p++; |
948 | 0 | } |
949 | 0 | } |
950 | | |
951 | | static char *scan_quote(CONF *conf, char *p) |
952 | 0 | { |
953 | 0 | int q = *p; |
954 | |
|
955 | 0 | p++; |
956 | 0 | while (!(IS_EOF(conf, *p)) && (*p != q)) { |
957 | 0 | if (IS_ESC(conf, *p)) { |
958 | 0 | p++; |
959 | 0 | if (IS_EOF(conf, *p)) |
960 | 0 | return p; |
961 | 0 | } |
962 | 0 | p++; |
963 | 0 | } |
964 | 0 | if (*p == q) |
965 | 0 | p++; |
966 | 0 | return p; |
967 | 0 | } |
968 | | |
969 | | static char *scan_dquote(CONF *conf, char *p) |
970 | 0 | { |
971 | 0 | int q = *p; |
972 | |
|
973 | 0 | p++; |
974 | 0 | while (!(IS_EOF(conf, *p))) { |
975 | 0 | if (*p == q) { |
976 | 0 | if (*(p + 1) == q) { |
977 | 0 | p++; |
978 | 0 | } else { |
979 | 0 | break; |
980 | 0 | } |
981 | 0 | } |
982 | 0 | p++; |
983 | 0 | } |
984 | 0 | if (*p == q) |
985 | 0 | p++; |
986 | 0 | return p; |
987 | 0 | } |
988 | | |
989 | | static void dump_value_doall_arg(const CONF_VALUE *a, BIO *out) |
990 | 0 | { |
991 | 0 | if (a->name) |
992 | 0 | BIO_printf(out, "[%s] %s=%s\n", a->section, a->name, a->value); |
993 | 0 | else |
994 | 0 | BIO_printf(out, "[[%s]]\n", a->section); |
995 | 0 | } |
996 | | |
997 | | IMPLEMENT_LHASH_DOALL_ARG_CONST(CONF_VALUE, BIO); |
998 | | |
999 | | static int def_dump(const CONF *conf, BIO *out) |
1000 | 0 | { |
1001 | 0 | lh_CONF_VALUE_doall_BIO(conf->data, dump_value_doall_arg, out); |
1002 | 0 | return 1; |
1003 | 0 | } |
1004 | | |
1005 | | static int def_is_number(const CONF *conf, char c) |
1006 | 0 | { |
1007 | 0 | return IS_NUMBER(conf, c); |
1008 | 0 | } |
1009 | | |
1010 | | static int def_to_int(const CONF *conf, char c) |
1011 | 0 | { |
1012 | 0 | return c - '0'; |
1013 | 0 | } |