Branch data Line data Source code
1 : : /*
2 : : ******************************************************************************
3 : : *
4 : : * File: access.c
5 : : *
6 : : * Purpose: Access.conf file processing for fwknop server.
7 : : *
8 : : * Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
9 : : * Copyright (C) 2009-2014 fwknop developers and contributors. For a full
10 : : * list of contributors, see the file 'CREDITS'.
11 : : *
12 : : * License (GNU General Public License):
13 : : *
14 : : * This program is free software; you can redistribute it and/or
15 : : * modify it under the terms of the GNU General Public License
16 : : * as published by the Free Software Foundation; either version 2
17 : : * of the License, or (at your option) any later version.
18 : : *
19 : : * This program is distributed in the hope that it will be useful,
20 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 : : * GNU General Public License for more details.
23 : : *
24 : : * You should have received a copy of the GNU General Public License
25 : : * along with this program; if not, write to the Free Software
26 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
27 : : * USA
28 : : *
29 : : ******************************************************************************
30 : : */
31 : : #include <sys/stat.h>
32 : :
33 : : #if HAVE_SYS_SOCKET_H
34 : : #include <sys/socket.h>
35 : : #endif
36 : :
37 : : #include "fwknopd_common.h"
38 : : #include <arpa/inet.h>
39 : : #include "pwd.h"
40 : : #include "access.h"
41 : : #include "utils.h"
42 : : #include "log_msg.h"
43 : :
44 : : #define FATAL_ERR -1
45 : :
46 : : #ifndef SUCCESS
47 : : #define SUCCESS 1
48 : : #endif
49 : :
50 : : /* Add an access string entry
51 : : */
52 : : static int
53 : 3951 : add_acc_string(char **var, const char *val)
54 : : {
55 [ - + ]: 3951 : if(var == NULL)
56 : : {
57 : 0 : log_msg(LOG_ERR, "[*] add_acc_string() called with NULL variable");
58 : 0 : return FATAL_ERR;
59 : : }
60 : :
61 [ - + ]: 3951 : if(*var != NULL)
62 : 0 : free(*var);
63 : :
64 [ - + ]: 3951 : if((*var = strdup(val)) == NULL)
65 : : {
66 : 0 : log_msg(LOG_ERR,
67 : : "[*] Fatal memory allocation error adding access list entry: %s", *var
68 : : );
69 : 0 : return FATAL_ERR;
70 : : }
71 : : return SUCCESS;
72 : : }
73 : :
74 : : /* Decode base64 encoded string into access entry
75 : : */
76 : : static int
77 : 532 : add_acc_b64_string(char **var, int *len, const char *val)
78 : : {
79 [ - + ]: 532 : if((*var = strdup(val)) == NULL)
80 : : {
81 : 0 : log_msg(LOG_ERR,
82 : : "[*] Fatal memory allocation error adding access list entry: %s", *var
83 : : );
84 : 0 : return FATAL_ERR;
85 : : }
86 : 532 : memset(*var, 0x0, strlen(val));
87 : 532 : *len = fko_base64_decode(val, (unsigned char *) *var);
88 : :
89 [ - + ]: 532 : if (*len < 0)
90 : : {
91 : 0 : log_msg(LOG_ERR,
92 : : "[*] base64 decoding returned error for: %s", *var
93 : : );
94 : 0 : return FATAL_ERR;
95 : : }
96 : : return SUCCESS;
97 : : }
98 : :
99 : : /* Add an access bool entry (unsigned char of 1 or 0)
100 : : */
101 : : static unsigned char
102 : 1756 : add_acc_bool(unsigned char *var, const char *val)
103 : : {
104 : 1756 : return(*var = (strncasecmp(val, "Y", 1) == 0) ? 1 : 0);
105 : : }
106 : :
107 : : /* Add expiration time - convert date to epoch seconds
108 : : */
109 : : static int
110 : 6 : add_acc_expire_time(fko_srv_options_t *opts, time_t *access_expire_time, const char *val)
111 : : {
112 : : struct tm tm;
113 : :
114 : : memset(&tm, 0, sizeof(struct tm));
115 : :
116 [ + + ]: 3 : if (sscanf(val, "%2d/%2d/%4d", &tm.tm_mon, &tm.tm_mday, &tm.tm_year) != 3)
117 : : {
118 : :
119 : 1 : log_msg(LOG_ERR,
120 : : "[*] Fatal: invalid date value '%s' (need MM/DD/YYYY) for access stanza expiration time",
121 : : val
122 : : );
123 : : return FATAL_ERR;
124 : : }
125 : :
126 [ + - ]: 2 : if(tm.tm_mon > 0)
127 : 2 : tm.tm_mon -= 1; /* 0-11 */
128 : :
129 : : /* number of years since 1900
130 : : */
131 [ + + ]: 2 : if(tm.tm_year > 1900)
132 : 1 : tm.tm_year -= 1900;
133 : : else
134 [ + - ]: 1 : if(tm.tm_year < 100)
135 : 1 : tm.tm_year += 100;
136 : :
137 : 2 : *access_expire_time = mktime(&tm);
138 : :
139 : : return 1;
140 : : }
141 : :
142 : : /* Add expiration time via epoch seconds defined in access.conf
143 : : */
144 : : static int
145 : 1 : add_acc_expire_time_epoch(fko_srv_options_t *opts, time_t *access_expire_time, const char *val)
146 : : {
147 : : char *endptr;
148 : 1 : unsigned long expire_time = 0;
149 : :
150 : 1 : errno = 0;
151 : :
152 : 1 : expire_time = (time_t) strtoul(val, &endptr, 10);
153 : :
154 [ + - ][ - + ]: 1 : if (errno == ERANGE || (errno != 0 && expire_time == 0))
[ # # ]
155 : : {
156 : 0 : log_msg(LOG_ERR,
157 : : "[*] Fatal: invalid epoch seconds value '%s' for access stanza expiration time",
158 : : val
159 : : );
160 : : return FATAL_ERR;
161 : : }
162 : :
163 : 1 : *access_expire_time = (time_t) expire_time;
164 : :
165 : : return 1;
166 : : }
167 : :
168 : : #if FIREWALL_IPTABLES
169 : : static int
170 : 28 : add_acc_force_nat(fko_srv_options_t *opts, acc_stanza_t *curr_acc, const char *val)
171 : : {
172 : 14 : char ip_str[MAX_IPV4_STR_LEN] = {0};
173 : :
174 [ + + ]: 14 : if (sscanf(val, "%15s %5u", ip_str, &curr_acc->force_nat_port) != 2)
175 : : {
176 : 1 : log_msg(LOG_ERR,
177 : : "[*] Fatal: invalid FORCE_NAT arg '%s', need <IP> <PORT>",
178 : : val
179 : : );
180 : : return FATAL_ERR;
181 : : }
182 : :
183 [ + + ]: 13 : if (curr_acc->force_nat_port > MAX_PORT)
184 : : {
185 : 1 : log_msg(LOG_ERR,
186 : : "[*] Fatal: invalid FORCE_NAT port '%d'", curr_acc->force_nat_port);
187 : : return FATAL_ERR;
188 : : }
189 : :
190 [ + + ]: 12 : if(! is_valid_ipv4_addr(ip_str))
191 : : {
192 : 1 : log_msg(LOG_ERR,
193 : : "[*] Fatal: invalid FORCE_NAT IP '%s'", ip_str);
194 : : return FATAL_ERR;
195 : : }
196 : :
197 : 11 : curr_acc->force_nat = 1;
198 : :
199 : 11 : return add_acc_string(&(curr_acc->force_nat_ip), ip_str);
200 : : }
201 : :
202 : : static int
203 : 10 : add_acc_force_snat(fko_srv_options_t *opts, acc_stanza_t *curr_acc, const char *val)
204 : : {
205 : 5 : char ip_str[MAX_IPV4_STR_LEN] = {0};
206 : :
207 [ - + ]: 5 : if (sscanf(val, "%15s", ip_str) != 1)
208 : : {
209 : 0 : log_msg(LOG_ERR,
210 : : "[*] Fatal: invalid FORCE_SNAT arg '%s', need <IP>", val);
211 : : return FATAL_ERR;
212 : : }
213 : :
214 [ + + ]: 5 : if(! is_valid_ipv4_addr(ip_str))
215 : : {
216 : 2 : log_msg(LOG_ERR,
217 : : "[*] Fatal: invalid FORCE_SNAT IP '%s'", ip_str);
218 : : return FATAL_ERR;
219 : : }
220 : :
221 : 3 : curr_acc->force_snat = 1;
222 : :
223 : 3 : return add_acc_string(&(curr_acc->force_snat_ip), ip_str);
224 : : }
225 : :
226 : : #endif
227 : :
228 : : /* Take an IP or Subnet/Mask and convert it to mask for later
229 : : * comparisons of incoming source IPs against this mask.
230 : : */
231 : : static int
232 : 1751 : add_source_mask(fko_srv_options_t *opts, acc_stanza_t *acc, const char *ip)
233 : : {
234 : : char *ndx;
235 : 1751 : char ip_str[MAX_IPV4_STR_LEN] = {0};
236 : 1751 : char ip_mask_str[MAX_IPV4_STR_LEN] = {0};
237 : : uint32_t mask;
238 : 1751 : int is_err, mask_len = 0, need_shift = 1;
239 : :
240 : : struct in_addr in;
241 : : struct in_addr mask_in;
242 : :
243 : : acc_int_list_t *last_sle, *new_sle, *tmp_sle;
244 : :
245 [ + + ]: 1751 : if((new_sle = calloc(1, sizeof(acc_int_list_t))) == NULL)
246 : : {
247 : 18 : log_msg(LOG_ERR,
248 : : "[*] Fatal memory allocation error adding stanza source_list entry"
249 : : );
250 : 18 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
251 : : }
252 : :
253 : : /* Convert the IP data into the appropriate IP + (optional) mask
254 : : */
255 [ + + ]: 1733 : if(strcasecmp(ip, "ANY") == 0)
256 : : {
257 : 1605 : new_sle->maddr = 0x0;
258 : 1605 : new_sle->mask = 0x0;
259 : : }
260 : : else
261 : : {
262 : : /* See if we have a subnet component. If so pull out the IP and
263 : : * mask values, then create the final mask value.
264 : : */
265 [ + + ]: 128 : if((ndx = strchr(ip, '/')) != NULL)
266 : : {
267 [ + + ]: 93 : if(((ndx-ip)) >= MAX_IPV4_STR_LEN)
268 : : {
269 : 1 : log_msg(LOG_ERR, "[*] Error parsing string to IP");
270 : 1 : free(new_sle);
271 : 1 : new_sle = NULL;
272 : : return 0;
273 : : }
274 : :
275 : 92 : mask_len = strlen(ip) - (ndx-ip+1);
276 : :
277 [ + + ]: 92 : if(mask_len > 2)
278 : : {
279 [ + + ]: 6 : if(mask_len >= MIN_IPV4_STR_LEN && mask_len < MAX_IPV4_STR_LEN)
280 : : {
281 : : /* IP formatted mask
282 : : */
283 : 5 : strlcpy(ip_mask_str, (ip + (ndx-ip) + 1), mask_len+1);
284 [ + + ]: 5 : if(inet_aton(ip_mask_str, &mask_in) == 0)
285 : : {
286 : 3 : log_msg(LOG_ERR,
287 : : "[*] Fatal error parsing IP mask to int for: %s", ip_mask_str
288 : : );
289 : 3 : free(new_sle);
290 : 3 : new_sle = NULL;
291 : : return 0;
292 : : }
293 : 2 : mask = ntohl(mask_in.s_addr);
294 : 2 : need_shift = 0;
295 : : }
296 : : else
297 : : {
298 : 1 : log_msg(LOG_ERR, "[*] Invalid IP mask str '%s'.", ndx+1);
299 : 1 : free(new_sle);
300 : 1 : new_sle = NULL;
301 : : return 0;
302 : : }
303 : : }
304 : : else
305 : : {
306 [ + + ]: 86 : if(mask_len > 0)
307 : : {
308 : : /* CIDR mask
309 : : */
310 : 85 : mask = strtol_wrapper(ndx+1, 1, 32, NO_EXIT_UPON_ERR, &is_err);
311 [ + + ]: 85 : if(is_err != FKO_SUCCESS)
312 : : {
313 : 3 : log_msg(LOG_ERR, "[*] Invalid IP mask str '%s'.", ndx+1);
314 : 3 : free(new_sle);
315 : 3 : new_sle = NULL;
316 : : return 0;
317 : : }
318 : : }
319 : : else
320 : : {
321 : 1 : log_msg(LOG_ERR, "[*] Missing mask value.");
322 : 1 : free(new_sle);
323 : 1 : new_sle = NULL;
324 : : return 0;
325 : : }
326 : : }
327 : :
328 : 84 : strlcpy(ip_str, ip, (ndx-ip)+1);
329 : : }
330 : : else
331 : : {
332 : 35 : mask = 32;
333 [ + + ]: 35 : if(strnlen(ip, MAX_IPV4_STR_LEN+1) >= MAX_IPV4_STR_LEN)
334 : : {
335 : 1 : log_msg(LOG_ERR, "[*] Error parsing string to IP");
336 : 1 : free(new_sle);
337 : 1 : new_sle = NULL;
338 : : return 0;
339 : : }
340 : 34 : strlcpy(ip_str, ip, sizeof(ip_str));
341 : : }
342 : :
343 [ + + ]: 118 : if(inet_aton(ip_str, &in) == 0)
344 : : {
345 : 1 : log_msg(LOG_ERR,
346 : : "[*] Fatal error parsing IP to int for: %s", ip_str
347 : : );
348 : :
349 : 1 : free(new_sle);
350 : 1 : new_sle = NULL;
351 : :
352 : : return 0;
353 : : }
354 : :
355 : : /* Store our mask converted from CIDR to a 32-bit value.
356 : : */
357 [ + + ]: 117 : if(mask == 32)
358 : 33 : new_sle->mask = 0xFFFFFFFF;
359 [ + + ][ + - ]: 84 : else if(need_shift && (mask > 0 && mask < 32))
360 : 82 : new_sle->mask = (0xFFFFFFFF << (32 - mask));
361 : : else
362 : 2 : new_sle->mask = mask;
363 : :
364 : : /* Store our masked address for comparisons with future incoming
365 : : * packets.
366 : : */
367 : 117 : new_sle->maddr = ntohl(in.s_addr) & new_sle->mask;
368 : : }
369 : :
370 : : /* If this is not the first entry, we walk our pointer to the
371 : : * end of the list.
372 : : */
373 [ + + ]: 1722 : if(acc->source_list == NULL)
374 : : {
375 : 1722 : acc->source_list = new_sle;
376 : : }
377 : : else
378 : : {
379 : : tmp_sle = acc->source_list;
380 : :
381 : : do {
382 : 181 : last_sle = tmp_sle;
383 [ + + ]: 181 : } while((tmp_sle = tmp_sle->next));
384 : :
385 : 82 : last_sle->next = new_sle;
386 : : }
387 : :
388 : : return 1;
389 : : }
390 : :
391 : : /* Expand the access SOURCE string to a list of masks.
392 : : */
393 : : static int
394 : 1667 : expand_acc_source(fko_srv_options_t *opts, acc_stanza_t *acc)
395 : : {
396 : : char *ndx, *start;
397 : 1667 : char buf[ACCESS_BUF_LEN] = {0};
398 : 1667 : int res = 1;
399 : :
400 : 1667 : start = acc->source;
401 : :
402 [ + + ]: 8287 : for(ndx = start; *ndx; ndx++)
403 : : {
404 [ + + ]: 6622 : if(*ndx == ',')
405 : : {
406 : : /* Skip over any leading whitespace.
407 : : */
408 [ + + ]: 144 : while(isspace(*start))
409 : 58 : start++;
410 : :
411 [ + - ]: 86 : if(((ndx-start)+1) >= ACCESS_BUF_LEN)
412 : : return 0;
413 : :
414 : 86 : strlcpy(buf, start, (ndx-start)+1);
415 : :
416 : 86 : res = add_source_mask(opts, acc, buf);
417 [ + + ]: 86 : if(res == 0)
418 : : return res;
419 : :
420 : 84 : start = ndx+1;
421 : : }
422 : : }
423 : :
424 : : /* Skip over any leading whitespace (once again for the last in the list).
425 : : */
426 [ + + ]: 1691 : while(isspace(*start))
427 : 26 : start++;
428 : :
429 [ + - ]: 1665 : if(((ndx-start)+1) >= ACCESS_BUF_LEN)
430 : : return 0;
431 : :
432 : 1665 : strlcpy(buf, start, (ndx-start)+1);
433 : :
434 : 1665 : res = add_source_mask(opts, acc, buf);
435 : :
436 : 1647 : return res;
437 : : }
438 : :
439 : : static int
440 : 878 : parse_proto_and_port(char *pstr, int *proto, int *port)
441 : : {
442 : : char *ndx;
443 : 878 : char proto_str[ACCESS_BUF_LEN] = {0};
444 : : int is_err;
445 : :
446 : : /* Parse the string into its components.
447 : : */
448 [ + + ]: 878 : if((ndx = strchr(pstr, '/')) == NULL)
449 : : {
450 : 1 : log_msg(LOG_ERR,
451 : : "[*] Parse error on access port entry: %s", pstr);
452 : :
453 : 1 : return(-1);
454 : : }
455 : :
456 [ - + ]: 877 : if(((ndx - pstr)+1) >= ACCESS_BUF_LEN)
457 : : {
458 : 0 : log_msg(LOG_ERR,
459 : : "[*] Parse error on access port entry: %s", pstr);
460 : 0 : return(-1);
461 : : }
462 : :
463 : 877 : strlcpy(proto_str, pstr, (ndx - pstr)+1);
464 : :
465 : 877 : *port = strtol_wrapper(ndx+1, 0, MAX_PORT, NO_EXIT_UPON_ERR, &is_err);
466 [ + + ]: 877 : if(is_err != FKO_SUCCESS)
467 : : {
468 : 1 : log_msg(LOG_ERR,
469 : : "[*] Invalid port '%s' in access request, must be in [%d,%d]",
470 : : pstr, 0, MAX_PORT);
471 : 1 : return(-1);
472 : : }
473 : :
474 [ + + ]: 876 : if(strcasecmp(proto_str, "tcp") == 0)
475 : 797 : *proto = PROTO_TCP;
476 [ + + ]: 79 : else if(strcasecmp(proto_str, "udp") == 0)
477 : 77 : *proto = PROTO_UDP;
478 : : else
479 : : {
480 : 2 : log_msg(LOG_ERR,
481 : : "[*] Invalid protocol in access port entry: %s", pstr);
482 : 2 : return(-1);
483 : : }
484 : :
485 : : return(0);
486 : : }
487 : :
488 : : /* Take a proto/port string and convert it to appropriate integer values
489 : : * for comparisons of incoming SPA requests.
490 : : */
491 : : static int
492 : 878 : add_port_list_ent(acc_port_list_t **plist, char *port_str)
493 : : {
494 : : int proto_int, port;
495 : :
496 : : acc_port_list_t *last_plist, *new_plist, *tmp_plist;
497 : :
498 : : /* Parse the string into its components and continue only if there
499 : : * are no problems with the incoming string.
500 : : */
501 [ + + ]: 878 : if(parse_proto_and_port(port_str, &proto_int, &port) != 0)
502 : : return 0;
503 : :
504 [ - + ]: 874 : if((new_plist = calloc(1, sizeof(acc_port_list_t))) == NULL)
505 : : {
506 : 0 : log_msg(LOG_ERR,
507 : : "[*] Fatal memory allocation error adding stanza source_list entry"
508 : : );
509 : 0 : exit(EXIT_FAILURE);
510 : : }
511 : :
512 : : /* If this is not the first entry, we walk our pointer to the
513 : : * end of the list.
514 : : */
515 [ + + ]: 874 : if(*plist == NULL)
516 : : {
517 : 874 : *plist = new_plist;
518 : : }
519 : : else
520 : : {
521 : : tmp_plist = *plist;
522 : :
523 : : do {
524 : 137 : last_plist = tmp_plist;
525 [ + + ]: 137 : } while((tmp_plist = tmp_plist->next));
526 : :
527 : 94 : last_plist->next = new_plist;
528 : : }
529 : :
530 : 874 : new_plist->proto = proto_int;
531 : 874 : new_plist->port = port;
532 : :
533 : 874 : return 1;
534 : : }
535 : :
536 : : /* Add a string list entry to the given acc_string_list.
537 : : */
538 : : static int
539 : 121 : add_string_list_ent(acc_string_list_t **stlist, const char *str_str)
540 : : {
541 : : acc_string_list_t *last_stlist, *new_stlist, *tmp_stlist;
542 : :
543 [ - + ]: 121 : if((new_stlist = calloc(1, sizeof(acc_string_list_t))) == NULL)
544 : : {
545 : 0 : log_msg(LOG_ERR,
546 : : "[*] Fatal memory allocation error creating string list entry"
547 : : );
548 : 0 : return FATAL_ERR;
549 : : }
550 : :
551 : : /* If this is not the first entry, we walk our pointer to the
552 : : * end of the list.
553 : : */
554 [ + + ]: 121 : if(*stlist == NULL)
555 : : {
556 : 121 : *stlist = new_stlist;
557 : : }
558 : : else
559 : : {
560 : : tmp_stlist = *stlist;
561 : :
562 : : do {
563 : 75 : last_stlist = tmp_stlist;
564 [ + + ]: 75 : } while((tmp_stlist = tmp_stlist->next));
565 : :
566 : 50 : last_stlist->next = new_stlist;
567 : : }
568 : :
569 [ - + ]: 121 : if(new_stlist->str != NULL)
570 : 0 : free(new_stlist->str);
571 : :
572 : 121 : new_stlist->str = strdup(str_str);
573 : :
574 [ - + ]: 121 : if(new_stlist->str == NULL)
575 : : {
576 : 0 : log_msg(LOG_ERR,
577 : : "[*] Fatal memory allocation error adding string list entry item"
578 : : );
579 : 0 : return FATAL_ERR;
580 : : }
581 : : return SUCCESS;
582 : : }
583 : :
584 : : /* Expand a proto/port access string to a list of access proto-port struct.
585 : : */
586 : : int
587 : 264 : expand_acc_port_list(acc_port_list_t **plist, char *plist_str)
588 : : {
589 : : char *ndx, *start;
590 : 264 : char buf[ACCESS_BUF_LEN] = {0};
591 : :
592 : 264 : start = plist_str;
593 : :
594 [ + + ]: 2413 : for(ndx = start; *ndx != '\0'; ndx++)
595 : : {
596 [ + + ]: 2150 : if(*ndx == ',')
597 : : {
598 : : /* Skip over any leading whitespace.
599 : : */
600 [ + + ]: 82 : while(isspace(*start))
601 : 31 : start++;
602 : :
603 [ + - ]: 51 : if(((ndx-start)+1) >= ACCESS_BUF_LEN)
604 : : return 0;
605 : :
606 : 51 : strlcpy(buf, start, (ndx-start)+1);
607 : :
608 [ + + ]: 51 : if(add_port_list_ent(plist, buf) == 0)
609 : : return 0;
610 : :
611 : 50 : start = ndx+1;
612 : : }
613 : : }
614 : :
615 : : /* Skip over any leading whitespace (once again for the last in the list).
616 : : */
617 [ + + ]: 278 : while(isspace(*start))
618 : 15 : start++;
619 : :
620 [ + + ]: 263 : if(((ndx-start)+1) >= ACCESS_BUF_LEN)
621 : : return 0;
622 : :
623 : 262 : strlcpy(buf, start, (ndx-start)+1);
624 : :
625 [ + + ]: 262 : if(add_port_list_ent(plist, buf) == 0)
626 : : return 0;
627 : :
628 : 259 : return 1;
629 : : }
630 : :
631 : : /* Expand a comma-separated string into a simple acc_string_list.
632 : : */
633 : : static int
634 : 71 : expand_acc_string_list(acc_string_list_t **stlist, char *stlist_str)
635 : : {
636 : : char *ndx, *start;
637 : 71 : char buf[MAX_LINE_LEN] = {0};
638 : :
639 : 71 : start = stlist_str;
640 : :
641 [ + + ]: 1235 : for(ndx = start; *ndx; ndx++)
642 : : {
643 [ + + ]: 1164 : if(*ndx == ',')
644 : : {
645 : : /* Skip over any leading whitespace.
646 : : */
647 [ + + ]: 75 : while(isspace(*start))
648 : 25 : start++;
649 : :
650 [ + - ]: 50 : if(((ndx-start)+1) >= MAX_LINE_LEN)
651 : : return FATAL_ERR;
652 : :
653 : 50 : strlcpy(buf, start, (ndx-start)+1);
654 [ + - ]: 50 : if(add_string_list_ent(stlist, buf) != SUCCESS)
655 : : return FATAL_ERR;
656 : :
657 : 50 : start = ndx+1;
658 : : }
659 : : }
660 : :
661 : : /* Skip over any leading whitespace (once again for the last in the list).
662 : : */
663 [ + + ]: 96 : while(isspace(*start))
664 : 25 : start++;
665 : :
666 [ + - ]: 71 : if(((ndx-start)+1) >= MAX_LINE_LEN)
667 : : return FATAL_ERR;
668 : :
669 : 71 : strlcpy(buf, start, (ndx-start)+1);
670 : :
671 [ + - ]: 71 : if(add_string_list_ent(stlist, buf) != SUCCESS)
672 : : return FATAL_ERR;
673 : :
674 : 71 : return SUCCESS;
675 : : }
676 : :
677 : : /* Free the acc source_list
678 : : */
679 : : static void
680 : 1684 : free_acc_source_list(acc_int_list_t *sle)
681 : : {
682 : : acc_int_list_t *last_sle;
683 : :
684 [ + + ]: 3396 : while(sle != NULL)
685 : : {
686 : 1712 : last_sle = sle;
687 : 1712 : sle = last_sle->next;
688 : :
689 : 1712 : free(last_sle);
690 : : }
691 : 1684 : }
692 : :
693 : : /* Free a port_list
694 : : */
695 : : void
696 : 786 : free_acc_port_list(acc_port_list_t *ple)
697 : : {
698 : : acc_port_list_t *last_ple;
699 : :
700 [ + + ]: 1660 : while(ple != NULL)
701 : : {
702 : 874 : last_ple = ple;
703 : 874 : ple = last_ple->next;
704 : :
705 : 874 : free(last_ple);
706 : : }
707 : 786 : }
708 : :
709 : : /* Free a string_list
710 : : */
711 : : static void
712 : 71 : free_acc_string_list(acc_string_list_t *stl)
713 : : {
714 : : acc_string_list_t *last_stl;
715 : :
716 [ + + ]: 192 : while(stl != NULL)
717 : : {
718 : 121 : last_stl = stl;
719 : 121 : stl = last_stl->next;
720 : :
721 : 121 : free(last_stl->str);
722 : 121 : free(last_stl);
723 : : }
724 : 71 : }
725 : :
726 : : static void
727 : 2410 : zero_buf_wrapper(char *buf, int len)
728 : : {
729 : :
730 [ - + ]: 2410 : if(zero_buf(buf, len) != FKO_SUCCESS)
731 : 0 : log_msg(LOG_ERR,
732 : : "[*] Could not zero out sensitive data buffer.");
733 : :
734 : 2410 : return;
735 : : }
736 : :
737 : : /* Free any allocated content of an access stanza.
738 : : *
739 : : * NOTE: If a new access.conf parameter is created, and it is a string
740 : : * value, it also needs to be added to the list of items to check
741 : : * and free below.
742 : : */
743 : : static void
744 : 1684 : free_acc_stanza_data(acc_stanza_t *acc)
745 : : {
746 : :
747 [ + - ]: 1684 : if(acc->source != NULL)
748 : : {
749 : 1684 : free(acc->source);
750 : 1684 : free_acc_source_list(acc->source_list);
751 : : }
752 : :
753 [ + + ]: 1684 : if(acc->open_ports != NULL)
754 : : {
755 : 29 : free(acc->open_ports);
756 : 29 : free_acc_port_list(acc->oport_list);
757 : : }
758 : :
759 [ + + ]: 1684 : if(acc->restrict_ports != NULL)
760 : : {
761 : 1 : free(acc->restrict_ports);
762 : 1 : free_acc_port_list(acc->rport_list);
763 : : }
764 : :
765 [ + + ]: 1684 : if(acc->force_nat_ip != NULL)
766 : 11 : free(acc->force_nat_ip);
767 : :
768 [ + + ]: 1684 : if(acc->force_snat_ip != NULL)
769 : 3 : free(acc->force_snat_ip);
770 : :
771 [ + + ]: 1684 : if(acc->key != NULL)
772 : : {
773 : 1625 : zero_buf_wrapper(acc->key, acc->key_len);
774 : 1625 : free(acc->key);
775 : : }
776 : :
777 [ + + ]: 1684 : if(acc->key_base64 != NULL)
778 : : {
779 : 241 : zero_buf_wrapper(acc->key_base64, strlen(acc->key_base64));
780 : 241 : free(acc->key_base64);
781 : : }
782 : :
783 [ + + ]: 1684 : if(acc->hmac_key != NULL)
784 : : {
785 : 275 : zero_buf_wrapper(acc->hmac_key, acc->hmac_key_len);
786 : 275 : free(acc->hmac_key);
787 : : }
788 : :
789 [ + + ]: 1684 : if(acc->hmac_key_base64 != NULL)
790 : : {
791 : 269 : zero_buf_wrapper(acc->hmac_key_base64, strlen(acc->hmac_key_base64));
792 : 269 : free(acc->hmac_key_base64);
793 : : }
794 : :
795 [ + + ]: 1684 : if(acc->cmd_exec_user != NULL)
796 : 1 : free(acc->cmd_exec_user);
797 : :
798 [ + + ]: 1684 : if(acc->require_username != NULL)
799 : 2 : free(acc->require_username);
800 : :
801 [ + + ]: 1684 : if(acc->gpg_home_dir != NULL)
802 : 72 : free(acc->gpg_home_dir);
803 : :
804 [ + + ]: 1684 : if(acc->gpg_exe != NULL)
805 : 1 : free(acc->gpg_exe);
806 : :
807 [ + + ]: 1684 : if(acc->gpg_decrypt_id != NULL)
808 : 72 : free(acc->gpg_decrypt_id);
809 : :
810 [ + + ]: 1684 : if(acc->gpg_decrypt_pw != NULL)
811 : 73 : free(acc->gpg_decrypt_pw);
812 : :
813 [ + + ]: 1684 : if(acc->gpg_remote_id != NULL)
814 : : {
815 : 68 : free(acc->gpg_remote_id);
816 : 68 : free_acc_string_list(acc->gpg_remote_id_list);
817 : : }
818 [ + + ]: 1684 : if(acc->gpg_remote_fpr != NULL)
819 : : {
820 : 3 : free(acc->gpg_remote_fpr);
821 : 3 : free_acc_string_list(acc->gpg_remote_fpr_list);
822 : : }
823 : 1684 : return;
824 : : }
825 : :
826 : : /* Expand any access entries that may be multi-value.
827 : : */
828 : : static void
829 : 1656 : expand_acc_ent_lists(fko_srv_options_t *opts)
830 : : {
831 : 1656 : acc_stanza_t *acc = opts->acc_stanzas;
832 : :
833 : : /* We need to do this for each stanza.
834 : : */
835 [ + + ]: 3289 : while(acc)
836 : : {
837 : : /* Expand the source string to 32-bit integer IP + masks for each entry.
838 : : */
839 [ + + ]: 1667 : if(expand_acc_source(opts, acc) == 0)
840 : : {
841 : 11 : log_msg(LOG_ERR, "[*] Fatal invalid SOURCE in access stanza");
842 : 11 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
843 : : }
844 : :
845 : : /* Now expand the open_ports string.
846 : : */
847 [ + + ][ + - ]: 1638 : if(acc->open_ports != NULL && strlen(acc->open_ports))
848 : : {
849 [ + + ]: 26 : if(expand_acc_port_list(&(acc->oport_list), acc->open_ports) == 0)
850 : : {
851 : 4 : log_msg(LOG_ERR, "[*] Fatal invalid OPEN_PORTS in access stanza");
852 : 4 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
853 : : }
854 : : }
855 : :
856 [ + + ][ + - ]: 1634 : if(acc->restrict_ports != NULL && strlen(acc->restrict_ports))
857 : : {
858 [ + - ]: 1 : if(expand_acc_port_list(&(acc->rport_list), acc->restrict_ports) == 0)
859 : : {
860 : 1 : log_msg(LOG_ERR, "[*] Fatal invalid RESTRICT_PORTS in access stanza");
861 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
862 : : }
863 : : }
864 : :
865 : : /* Expand the GPG_REMOTE_ID string.
866 : : */
867 [ + + ][ + - ]: 1633 : if(acc->gpg_remote_id != NULL && strlen(acc->gpg_remote_id))
868 : : {
869 [ - + ]: 68 : if(expand_acc_string_list(&(acc->gpg_remote_id_list),
870 : : acc->gpg_remote_id) != SUCCESS)
871 : : {
872 : 0 : log_msg(LOG_ERR, "[*] Fatal invalid GPG_REMOTE_ID list in access stanza");
873 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
874 : : }
875 : : }
876 : :
877 : : /* Expand the GPG_FINGERPRINT_ID string.
878 : : */
879 [ + + ][ + - ]: 1633 : if(acc->gpg_remote_fpr != NULL && strlen(acc->gpg_remote_fpr))
880 : : {
881 [ - + ]: 3 : if(expand_acc_string_list(&(acc->gpg_remote_fpr_list),
882 : : acc->gpg_remote_fpr) != SUCCESS)
883 : : {
884 : 0 : log_msg(LOG_ERR, "[*] Fatal invalid GPG_FINGERPRINT_ID list in access stanza");
885 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
886 : : }
887 : : }
888 : :
889 : 1633 : acc = acc->next;
890 : : }
891 : 1622 : return;
892 : : }
893 : :
894 : : void
895 : 7007 : free_acc_stanzas(fko_srv_options_t *opts)
896 : : {
897 : : acc_stanza_t *acc, *last_acc;
898 : :
899 : : /* Free any resources first (in case of reconfig). Assume non-NULL
900 : : * entry needs to be freed.
901 : : */
902 : 7007 : acc = opts->acc_stanzas;
903 : :
904 [ + + ]: 8691 : while(acc != NULL)
905 : : {
906 : 1684 : last_acc = acc;
907 : 1684 : acc = last_acc->next;
908 : :
909 : 1684 : free_acc_stanza_data(last_acc);
910 : 1684 : free(last_acc);
911 : : }
912 : :
913 : 7007 : return;
914 : : }
915 : :
916 : : /* Wrapper for free_acc_stanzas(), we may put additional initialization
917 : : * code here.
918 : : */
919 : : static void
920 : 1694 : acc_stanza_init(fko_srv_options_t *opts)
921 : : {
922 : : /* Free any resources first (in case of reconfig). Assume non-NULL
923 : : * entry needs to be freed.
924 : : */
925 : 1694 : free_acc_stanzas(opts);
926 : :
927 : 1694 : return;
928 : : }
929 : :
930 : : /* Add a new stanza bay allocating the required memory at the required
931 : : * location, yada-yada-yada.
932 : : */
933 : : static acc_stanza_t*
934 : 1706 : acc_stanza_add(fko_srv_options_t *opts)
935 : : {
936 : 1706 : acc_stanza_t *acc = opts->acc_stanzas;
937 : 1706 : acc_stanza_t *new_acc = calloc(1, sizeof(acc_stanza_t));
938 : : acc_stanza_t *last_acc;
939 : :
940 [ + + ]: 1706 : if(new_acc == NULL)
941 : : {
942 : 12 : log_msg(LOG_ERR,
943 : : "[*] Fatal memory allocation error adding access stanza"
944 : : );
945 : 12 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
946 : : }
947 : :
948 : : /* If this is not the first acc entry, we walk our acc pointer to the
949 : : * end of the existing list.
950 : : */
951 [ + + ]: 1694 : if(acc == NULL)
952 : : {
953 : 1694 : opts->acc_stanzas = new_acc;
954 : : }
955 : : else
956 : : {
957 : : do {
958 : 22 : last_acc = acc;
959 [ + + ]: 22 : } while((acc = acc->next));
960 : :
961 : 13 : last_acc->next = new_acc;
962 : : }
963 : :
964 : 1694 : return(new_acc);
965 : : }
966 : :
967 : : /* Scan the access options for entries that have not been set, but need
968 : : * a default value.
969 : : */
970 : : static void
971 : 1622 : set_acc_defaults(fko_srv_options_t *opts)
972 : : {
973 : 1622 : acc_stanza_t *acc = opts->acc_stanzas;
974 : 1622 : int i=1;
975 : :
976 [ + - ]: 1622 : if(!acc)
977 : : return;
978 : :
979 [ + + ]: 3254 : while(acc)
980 : : {
981 : : /* set default fw_access_timeout if necessary
982 : : */
983 [ + + ]: 1633 : if(acc->fw_access_timeout < 1)
984 : 14 : acc->fw_access_timeout = DEF_FW_ACCESS_TIMEOUT;
985 : :
986 : : /* set default gpg keyring path if necessary
987 : : */
988 [ + + ]: 1633 : if(acc->gpg_decrypt_pw != NULL)
989 : : {
990 [ - + ]: 72 : if(acc->gpg_home_dir == NULL)
991 [ # # ]: 0 : if(add_acc_string(&(acc->gpg_home_dir), opts->config[CONF_GPG_HOME_DIR]) != SUCCESS)
992 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
993 : :
994 [ + - ]: 72 : if(! acc->gpg_require_sig)
995 : : {
996 [ + + ]: 72 : if (acc->gpg_disable_sig)
997 : : {
998 : 1 : log_msg(LOG_INFO,
999 : : "Warning: GPG_REQUIRE_SIG should really be enabled for stanza source: '%s' (#%d)",
1000 : : acc->source, i
1001 : : );
1002 : : }
1003 : : else
1004 : : {
1005 : : /* Make this the default unless explicitly disabled
1006 : : */
1007 : 71 : acc->gpg_require_sig = 1;
1008 : : }
1009 : : }
1010 : : else
1011 : : {
1012 [ # # ]: 0 : if (acc->gpg_disable_sig)
1013 : : {
1014 : 0 : log_msg(LOG_INFO,
1015 : : "Warning: GPG_REQUIRE_SIG and GPG_DISABLE_SIG are both set, will check sigs (stanza source: '%s' #%d)",
1016 : : acc->source, i
1017 : : );
1018 : : }
1019 : : }
1020 : :
1021 : : /* If signature checking is enabled, make sure we either have sig ID's or
1022 : : * fingerprint ID's to check
1023 : : */
1024 [ + + ]: 72 : if(! acc->gpg_disable_sig
1025 [ + + ][ + + ]: 71 : && (acc->gpg_remote_id == NULL && acc->gpg_remote_fpr == NULL))
1026 : : {
1027 : 1 : log_msg(LOG_INFO,
1028 : : "Warning: Must have either sig ID's or fingerprints to check via GPG_REMOTE_ID or GPG_FINGERPRINT_ID (stanza source: '%s' #%d)",
1029 : : acc->source, i
1030 : : );
1031 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1032 : : }
1033 : : }
1034 : :
1035 [ + + ]: 1632 : if(acc->encryption_mode == FKO_ENC_MODE_UNKNOWN)
1036 : 1605 : acc->encryption_mode = FKO_DEFAULT_ENC_MODE;
1037 : :
1038 : : /* if we're using an HMAC key and the HMAC digest type was not
1039 : : * set for HMAC_DIGEST_TYPE, then assume it's SHA256
1040 : : */
1041 : :
1042 [ + + ]: 1632 : if(acc->hmac_type == FKO_HMAC_UNKNOWN
1043 [ + + ][ + - ]: 1579 : && acc->hmac_key_len > 0 && acc->hmac_key != NULL)
1044 : : {
1045 : 224 : acc->hmac_type = FKO_DEFAULT_HMAC_MODE;
1046 : : }
1047 : :
1048 : 1632 : acc = acc->next;
1049 : 1632 : i++;
1050 : : }
1051 : : return;
1052 : : }
1053 : :
1054 : : /* Perform some sanity checks on an acc stanza data.
1055 : : */
1056 : : static int
1057 : 1674 : acc_data_is_valid(acc_stanza_t * const acc)
1058 : : {
1059 [ - + ]: 1674 : if(acc == NULL)
1060 : : {
1061 : 0 : log_msg(LOG_ERR,
1062 : : "[*] acc_data_is_valid() called with NULL acc stanza");
1063 : 0 : return(0);
1064 : : }
1065 : :
1066 [ + + ][ - + ]: 1674 : if(((acc->key == NULL || acc->key_len == 0)
1067 [ + + ][ + + ]: 49 : && ((acc->gpg_decrypt_pw == NULL || !strlen(acc->gpg_decrypt_pw))
1068 [ + + ]: 33 : && acc->gpg_allow_no_pw == 0))
1069 [ + + ][ - + ]: 1673 : || (acc->use_rijndael == 0 && acc->use_gpg == 0 && acc->gpg_allow_no_pw == 0))
1070 : : {
1071 : 1 : log_msg(LOG_ERR,
1072 : : "[*] No keys found for access stanza source: '%s'", acc->source
1073 : : );
1074 : 1 : return(0);
1075 : : }
1076 : :
1077 [ + + ][ + - ]: 1673 : if(acc->use_rijndael && acc->key != NULL)
1078 : : {
1079 [ + + ]: 1625 : if((acc->encryption_mode == FKO_ENC_MODE_CBC_LEGACY_IV)
1080 [ + + ]: 23 : && (acc->key_len > 16))
1081 : : {
1082 : 1 : log_msg(LOG_INFO,
1083 : : "Warning: truncating encryption key in legacy mode to 16 bytes for access stanza source: '%s'",
1084 : : acc->source
1085 : : );
1086 : 1 : acc->key_len = 16;
1087 : : }
1088 : : }
1089 : :
1090 [ + + ][ + - ]: 1673 : if((acc->hmac_key_len) != 0 && (acc->hmac_key != NULL))
1091 : : {
1092 [ + + ][ + - ]: 285 : if((acc->key != NULL) && (acc->key_len != 0)
1093 [ + + ]: 255 : && (acc->key_len == acc->hmac_key_len))
1094 : : {
1095 [ + + ]: 3 : if(memcmp(acc->key, acc->hmac_key, acc->hmac_key_len) == 0)
1096 : : {
1097 : 1 : log_msg(LOG_ERR,
1098 : : "[*] The encryption passphrase and HMAC key should not be identical for access stanza source: '%s'",
1099 : : acc->source
1100 : : );
1101 : 1 : return(0);
1102 : : }
1103 : : }
1104 [ + + ]: 282 : else if((acc->gpg_allow_no_pw == 0)
1105 [ + + ]: 268 : && acc->gpg_decrypt_pw != NULL
1106 [ + + ]: 16 : && (strlen(acc->gpg_decrypt_pw) == acc->hmac_key_len))
1107 : : {
1108 [ + - ]: 1 : if(memcmp(acc->gpg_decrypt_pw, acc->hmac_key, acc->hmac_key_len) == 0)
1109 : : {
1110 : 1 : log_msg(LOG_ERR,
1111 : : "[*] The encryption passphrase and HMAC key should not be identical for access stanza source: '%s'",
1112 : : acc->source
1113 : : );
1114 : 1 : return(0);
1115 : : }
1116 : : }
1117 : : }
1118 : :
1119 [ + + ][ + + ]: 1671 : if(acc->force_snat == 1 && acc->force_nat == 0)
1120 : : {
1121 : 2 : log_msg(LOG_ERR,
1122 : : "[*] FORCE_SNAT implies FORCE_NAT must also be used for access stanza source: '%s'",
1123 : : acc->source
1124 : : );
1125 : 2 : return(0);
1126 : : }
1127 : :
1128 [ + + ][ - + ]: 1669 : if(acc->force_masquerade == 1 && acc->force_nat == 0)
1129 : : {
1130 : 0 : log_msg(LOG_ERR,
1131 : : "[*] FORCE_MASQUERADE implies FORCE_NAT must also be used for access stanza source: '%s'",
1132 : : acc->source
1133 : : );
1134 : 0 : return(0);
1135 : : }
1136 : :
1137 [ + + ]: 1669 : if(acc->require_source_address == 0)
1138 : : {
1139 : 1667 : log_msg(LOG_INFO,
1140 : : "Warning: REQUIRE_SOURCE_ADDRESS not enabled for access stanza source: '%s'",
1141 : : acc->source
1142 : : );
1143 : : }
1144 : :
1145 : : return(1);
1146 : : }
1147 : :
1148 : : /* Read and parse the access file, popluating the access data as we go.
1149 : : */
1150 : : void
1151 : 1710 : parse_access_file(fko_srv_options_t *opts)
1152 : : {
1153 : : FILE *file_ptr;
1154 : : char *ndx;
1155 : 1710 : int got_source = 0, is_err;
1156 : 1710 : unsigned int num_lines = 0;
1157 : :
1158 : 1710 : char access_line_buf[MAX_LINE_LEN] = {0};
1159 : 1710 : char var[MAX_LINE_LEN] = {0};
1160 : 1710 : char val[MAX_LINE_LEN] = {0};
1161 : :
1162 : : struct passwd *pw;
1163 : : struct stat st;
1164 : :
1165 : 1710 : acc_stanza_t *curr_acc = NULL;
1166 : :
1167 : : /* First see if the access file exists. If it doesn't, complain
1168 : : * and bail.
1169 : : */
1170 [ + + ]: 1710 : if(stat(opts->config[CONF_ACCESS_FILE], &st) != 0)
1171 : : {
1172 : 1 : log_msg(LOG_ERR, "[*] Access file: '%s' was not found.",
1173 : : opts->config[CONF_ACCESS_FILE]);
1174 : :
1175 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1176 : : }
1177 : :
1178 [ - + ]: 1709 : if(verify_file_perms_ownership(opts->config[CONF_ACCESS_FILE]) != 1)
1179 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1180 : :
1181 : : /* A note on security here: Coverity flags the following fopen() as a
1182 : : * Time of check time of use (TOCTOU) bug with a low priority due to the
1183 : : * previous stat() call above. I.e., the access.conf file on disk could
1184 : : * have been changed between the stat() and the fopen() causing a TOCTOU
1185 : : * bug. While technically this is true, the return value of fopen() is
1186 : : * also checked below so stat() success does not imply we assume fopen()
1187 : : * success. Also, we could just remove the stat() and
1188 : : * verify_file_perms_ownership() calls above to "fix" the bug, but this
1189 : : * would actually make things easier for an attacker that has already
1190 : : * compromised the local system since access.conf could be changed to, say,
1191 : : * a symbolic link (for which verify_file_perms_ownership() throws a
1192 : : * warning), and then there is no race at all before the fopen(). I.e.
1193 : : * forcing an attacker to do the race makes things harder for them.
1194 : : */
1195 [ + + ]: 1709 : if ((file_ptr = fopen(opts->config[CONF_ACCESS_FILE], "r")) == NULL)
1196 : : {
1197 : 15 : log_msg(LOG_ERR, "[*] Could not open access file: %s",
1198 : : opts->config[CONF_ACCESS_FILE]);
1199 : 15 : perror(NULL);
1200 : :
1201 : 15 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1202 : : }
1203 : :
1204 : : /* Initialize the access list.
1205 : : */
1206 : 1694 : acc_stanza_init(opts);
1207 : :
1208 : : /* Now walk through access file pulling the access entries into the
1209 : : * current stanza.
1210 : : */
1211 [ + + ]: 9089 : while ((fgets(access_line_buf, MAX_LINE_LEN, file_ptr)) != NULL)
1212 : : {
1213 : 5734 : num_lines++;
1214 : 5734 : access_line_buf[MAX_LINE_LEN-1] = '\0';
1215 : :
1216 : : /* Get past comments and empty lines (note: we only look at the
1217 : : * first character.
1218 : : */
1219 [ + + ][ + - ]: 5734 : if(IS_EMPTY_LINE(access_line_buf[0]))
[ + - ][ - + ]
1220 : 8 : continue;
1221 : :
1222 [ + + ]: 5726 : if(sscanf(access_line_buf, "%s %[^;\n\r]", var, val) != 2)
1223 : : {
1224 : 1 : log_msg(LOG_ERR,
1225 : : "[*] Invalid access file entry in %s at line %i.\n - '%s'",
1226 : : opts->config[CONF_ACCESS_FILE], num_lines, access_line_buf
1227 : : );
1228 : 1 : fclose(file_ptr);
1229 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1230 : : }
1231 : :
1232 : : /* Remove any colon that may be on the end of the var
1233 : : */
1234 [ + + ]: 5725 : if((ndx = strrchr(var, ':')) != NULL)
1235 : 15 : *ndx = '\0';
1236 : :
1237 : : /* Even though sscanf should automatically add a terminating
1238 : : * NULL byte, an assumption is made that the input arrays are
1239 : : * big enough, so we'll force a terminating NULL byte regardless
1240 : : */
1241 : 5725 : var[MAX_LINE_LEN-1] = 0x0;
1242 : 5725 : val[MAX_LINE_LEN-1] = 0x0;
1243 : :
1244 [ + + ]: 5725 : if (opts->verbose > 3)
1245 : 12 : log_msg(LOG_DEBUG,
1246 : : "ACCESS FILE: %s, LINE: %s\tVar: %s, Val: '%s'",
1247 : : opts->config[CONF_ACCESS_FILE], access_line_buf, var, val
1248 : : );
1249 : :
1250 : : /* Process the entry.
1251 : : *
1252 : : * NOTE: If a new access.conf parameter is created. It also needs
1253 : : * to be accounted for in the following if/if else construct.
1254 : : */
1255 [ + + ]: 5725 : if(CONF_VAR_IS(var, "SOURCE"))
1256 : : {
1257 : : /* If this is not the first stanza, sanity check the previous
1258 : : * stanza for the minimum required data.
1259 : : */
1260 [ + + ]: 1707 : if(curr_acc != NULL) {
1261 [ + + ]: 14 : if(!acc_data_is_valid(curr_acc))
1262 : : {
1263 : 1 : log_msg(LOG_ERR, "[*] Data error in access file: '%s'",
1264 : : opts->config[CONF_ACCESS_FILE]);
1265 : 1 : fclose(file_ptr);
1266 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1267 : : }
1268 : : }
1269 : :
1270 : : /* Start new stanza.
1271 : : */
1272 : 1706 : curr_acc = acc_stanza_add(opts);
1273 : :
1274 [ - + ]: 1694 : if(add_acc_string(&(curr_acc->source), val) != SUCCESS)
1275 : : {
1276 : 0 : fclose(file_ptr);
1277 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1278 : : }
1279 : :
1280 : 1694 : got_source++;
1281 : : }
1282 [ + + ]: 4018 : else if (curr_acc == NULL)
1283 : : {
1284 : : /* The stanza must start with the "SOURCE" variable
1285 : : */
1286 : 1 : continue;
1287 : : }
1288 [ + + ]: 4017 : else if(CONF_VAR_IS(var, "OPEN_PORTS"))
1289 : : {
1290 [ - + ]: 29 : if(add_acc_string(&(curr_acc->open_ports), val) != SUCCESS)
1291 : : {
1292 : 0 : fclose(file_ptr);
1293 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1294 : : }
1295 : : }
1296 [ + + ]: 3988 : else if(CONF_VAR_IS(var, "RESTRICT_PORTS"))
1297 : : {
1298 [ - + ]: 1 : if(add_acc_string(&(curr_acc->restrict_ports), val) != SUCCESS)
1299 : : {
1300 : 0 : fclose(file_ptr);
1301 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1302 : : }
1303 : : }
1304 [ + + ]: 3987 : else if(CONF_VAR_IS(var, "KEY"))
1305 : : {
1306 [ + + ]: 1384 : if(strcasecmp(val, "__CHANGEME__") == 0)
1307 : : {
1308 : 1 : log_msg(LOG_ERR,
1309 : : "[*] KEY value is not properly set in stanza source '%s' in access file: '%s'",
1310 : : curr_acc->source, opts->config[CONF_ACCESS_FILE]);
1311 : 1 : fclose(file_ptr);
1312 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1313 : : }
1314 [ - + ]: 1383 : if(add_acc_string(&(curr_acc->key), val) != SUCCESS)
1315 : : {
1316 : 0 : fclose(file_ptr);
1317 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1318 : : }
1319 : 1383 : curr_acc->key_len = strlen(curr_acc->key);
1320 : 1383 : add_acc_bool(&(curr_acc->use_rijndael), "Y");
1321 : : }
1322 [ + + ]: 2603 : else if(CONF_VAR_IS(var, "KEY_BASE64"))
1323 : : {
1324 [ + + ]: 254 : if(strcasecmp(val, "__CHANGEME__") == 0)
1325 : : {
1326 : 1 : log_msg(LOG_ERR,
1327 : : "[*] KEY_BASE64 value is not properly set in stanza source '%s' in access file: '%s'",
1328 : : curr_acc->source, opts->config[CONF_ACCESS_FILE]);
1329 : 1 : fclose(file_ptr);
1330 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1331 : : }
1332 [ + + ]: 253 : if (! is_base64((unsigned char *) val, strlen(val)))
1333 : : {
1334 : 1 : log_msg(LOG_ERR,
1335 : : "[*] KEY_BASE64 argument '%s' doesn't look like base64-encoded data.",
1336 : : val);
1337 : 1 : fclose(file_ptr);
1338 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1339 : : }
1340 [ - + ]: 252 : if(add_acc_string(&(curr_acc->key_base64), val) != SUCCESS)
1341 : : {
1342 : 0 : fclose(file_ptr);
1343 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1344 : : }
1345 [ - + ]: 252 : if(add_acc_b64_string(&(curr_acc->key),
1346 : 252 : &(curr_acc->key_len), curr_acc->key_base64) != SUCCESS)
1347 : : {
1348 : 0 : fclose(file_ptr);
1349 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1350 : : }
1351 : 252 : add_acc_bool(&(curr_acc->use_rijndael), "Y");
1352 : : }
1353 : : /* HMAC digest type */
1354 [ + + ]: 2349 : else if(CONF_VAR_IS(var, "HMAC_DIGEST_TYPE"))
1355 : : {
1356 : 54 : curr_acc->hmac_type = hmac_digest_strtoint(val);
1357 [ + + ]: 54 : if(curr_acc->hmac_type < 0)
1358 : : {
1359 : 1 : log_msg(LOG_ERR,
1360 : : "[*] HMAC_DIGEST_TYPE argument '%s' must be one of {md5,sha1,sha256,sha384,sha512}",
1361 : : val);
1362 : 1 : fclose(file_ptr);
1363 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1364 : : }
1365 : : }
1366 [ + + ]: 2295 : else if(CONF_VAR_IS(var, "HMAC_KEY_BASE64"))
1367 : : {
1368 [ + + ]: 282 : if(strcasecmp(val, "__CHANGEME__") == 0)
1369 : : {
1370 : 1 : log_msg(LOG_ERR,
1371 : : "[*] HMAC_KEY_BASE64 value is not properly set in stanza source '%s' in access file: '%s'",
1372 : : curr_acc->source, opts->config[CONF_ACCESS_FILE]);
1373 : 1 : fclose(file_ptr);
1374 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1375 : : }
1376 [ + + ]: 281 : if (! is_base64((unsigned char *) val, strlen(val)))
1377 : : {
1378 : 1 : log_msg(LOG_ERR,
1379 : : "[*] HMAC_KEY_BASE64 argument '%s' doesn't look like base64-encoded data.",
1380 : : val);
1381 : 1 : fclose(file_ptr);
1382 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1383 : : }
1384 [ - + ]: 280 : if(add_acc_string(&(curr_acc->hmac_key_base64), val) != SUCCESS)
1385 : : {
1386 : 0 : fclose(file_ptr);
1387 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1388 : : }
1389 [ - + ]: 280 : if(add_acc_b64_string(&(curr_acc->hmac_key),
1390 : 280 : &(curr_acc->hmac_key_len), curr_acc->hmac_key_base64) != SUCCESS)
1391 : : {
1392 : 0 : fclose(file_ptr);
1393 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1394 : : }
1395 : : }
1396 [ + + ]: 2013 : else if(CONF_VAR_IS(var, "HMAC_KEY"))
1397 : : {
1398 [ + + ]: 7 : if(strcasecmp(val, "__CHANGEME__") == 0)
1399 : : {
1400 : 1 : log_msg(LOG_ERR,
1401 : : "[*] HMAC_KEY value is not properly set in stanza source '%s' in access file: '%s'",
1402 : : curr_acc->source, opts->config[CONF_ACCESS_FILE]);
1403 : 1 : fclose(file_ptr);
1404 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1405 : : }
1406 [ - + ]: 6 : if(add_acc_string(&(curr_acc->hmac_key), val) != SUCCESS)
1407 : : {
1408 : 0 : fclose(file_ptr);
1409 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1410 : : }
1411 : 6 : curr_acc->hmac_key_len = strlen(curr_acc->hmac_key);
1412 : : }
1413 [ + + ]: 2006 : else if(CONF_VAR_IS(var, "FW_ACCESS_TIMEOUT"))
1414 : : {
1415 : 1646 : curr_acc->fw_access_timeout = strtol_wrapper(val, 0,
1416 : : RCHK_MAX_FW_TIMEOUT, NO_EXIT_UPON_ERR, &is_err);
1417 [ + + ]: 1646 : if(is_err != FKO_SUCCESS)
1418 : : {
1419 : 1 : log_msg(LOG_ERR,
1420 : : "[*] FW_ACCESS_TIMEOUT value not in range.");
1421 : 1 : fclose(file_ptr);
1422 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1423 : : }
1424 : : }
1425 [ + + ]: 360 : else if(CONF_VAR_IS(var, "ENCRYPTION_MODE"))
1426 : : {
1427 [ + + ]: 28 : if((curr_acc->encryption_mode = enc_mode_strtoint(val)) < 0)
1428 : : {
1429 : 1 : log_msg(LOG_ERR,
1430 : : "[*] Unrecognized ENCRYPTION_MODE '%s', use {CBC,CTR,legacy,Asymmetric}",
1431 : : val);
1432 : 1 : fclose(file_ptr);
1433 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1434 : : }
1435 : : }
1436 [ + + ]: 332 : else if(CONF_VAR_IS(var, "ENABLE_CMD_EXEC"))
1437 : : {
1438 : 3 : add_acc_bool(&(curr_acc->enable_cmd_exec), val);
1439 : : }
1440 [ + + ]: 329 : else if(CONF_VAR_IS(var, "CMD_EXEC_USER"))
1441 : : {
1442 [ - + ]: 1 : if(add_acc_string(&(curr_acc->cmd_exec_user), val) != SUCCESS)
1443 : : {
1444 : 0 : fclose(file_ptr);
1445 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1446 : : }
1447 : :
1448 : 1 : errno = 0;
1449 : 1 : pw = getpwnam(val);
1450 : :
1451 [ + - ]: 1 : if(pw == NULL)
1452 : : {
1453 [ - + ]: 1 : log_msg(LOG_ERR, "[*] Unable to determine UID for CMD_EXEC_USER: %s.",
1454 : 1 : errno ? strerror(errno) : "Not a user on this system");
1455 : 1 : fclose(file_ptr);
1456 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1457 : : }
1458 : :
1459 : 0 : curr_acc->cmd_exec_uid = pw->pw_uid;
1460 : : }
1461 [ + + ]: 328 : else if(CONF_VAR_IS(var, "REQUIRE_USERNAME"))
1462 : : {
1463 [ - + ]: 2 : if(add_acc_string(&(curr_acc->require_username), val) != SUCCESS)
1464 : : {
1465 : 0 : fclose(file_ptr);
1466 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1467 : : }
1468 : : }
1469 [ + + ]: 326 : else if(CONF_VAR_IS(var, "REQUIRE_SOURCE_ADDRESS"))
1470 : : {
1471 : 2 : add_acc_bool(&(curr_acc->require_source_address), val);
1472 : : }
1473 [ + + ]: 324 : else if(CONF_VAR_IS(var, "REQUIRE_SOURCE")) /* synonym for REQUIRE_SOURCE_ADDRESS */
1474 : : {
1475 : 1 : add_acc_bool(&(curr_acc->require_source_address), val);
1476 : : }
1477 [ + + ]: 323 : else if(CONF_VAR_IS(var, "GPG_HOME_DIR"))
1478 : : {
1479 [ + - ]: 72 : if (is_valid_dir(val))
1480 : : {
1481 [ - + ]: 72 : if(add_acc_string(&(curr_acc->gpg_home_dir), val) != SUCCESS)
1482 : : {
1483 : 0 : fclose(file_ptr);
1484 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1485 : : }
1486 : : }
1487 : : else
1488 : : {
1489 : 0 : log_msg(LOG_ERR,
1490 : : "[*] GPG_HOME_DIR directory '%s' stat()/existence problem in stanza source '%s' in access file: '%s'",
1491 : : val, curr_acc->source, opts->config[CONF_ACCESS_FILE]);
1492 : 0 : fclose(file_ptr);
1493 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1494 : : }
1495 : : }
1496 [ + + ]: 251 : else if(CONF_VAR_IS(var, "GPG_EXE"))
1497 : : {
1498 [ - + ]: 1 : if(add_acc_string(&(curr_acc->gpg_exe), val) != SUCCESS)
1499 : : {
1500 : 0 : fclose(file_ptr);
1501 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1502 : : }
1503 : : }
1504 [ + + ]: 250 : else if(CONF_VAR_IS(var, "GPG_DECRYPT_ID"))
1505 : : {
1506 [ - + ]: 72 : if(add_acc_string(&(curr_acc->gpg_decrypt_id), val) != SUCCESS)
1507 : : {
1508 : 0 : fclose(file_ptr);
1509 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1510 : : }
1511 : : }
1512 [ + + ]: 178 : else if(CONF_VAR_IS(var, "GPG_DECRYPT_PW"))
1513 : : {
1514 [ + + ]: 42 : if(strcasecmp(val, "__CHANGEME__") == 0)
1515 : : {
1516 : 1 : log_msg(LOG_ERR,
1517 : : "[*] GPG_DECRYPT_PW value is not properly set in stanza source '%s' in access file: '%s'",
1518 : : curr_acc->source, opts->config[CONF_ACCESS_FILE]);
1519 : 1 : fclose(file_ptr);
1520 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1521 : : }
1522 [ - + ]: 41 : if(add_acc_string(&(curr_acc->gpg_decrypt_pw), val) != SUCCESS)
1523 : : {
1524 : 0 : fclose(file_ptr);
1525 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1526 : : }
1527 : 41 : add_acc_bool(&(curr_acc->use_gpg), "Y");
1528 : : }
1529 [ + + ]: 136 : else if(CONF_VAR_IS(var, "GPG_ALLOW_NO_PW"))
1530 : : {
1531 : 32 : add_acc_bool(&(curr_acc->gpg_allow_no_pw), val);
1532 [ + - ]: 32 : if(curr_acc->gpg_allow_no_pw == 1)
1533 : : {
1534 : 32 : add_acc_bool(&(curr_acc->use_gpg), "Y");
1535 [ - + ]: 32 : if(add_acc_string(&(curr_acc->gpg_decrypt_pw), "") != SUCCESS)
1536 : : {
1537 : 0 : fclose(file_ptr);
1538 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1539 : : }
1540 : : }
1541 : : }
1542 [ + + ]: 104 : else if(CONF_VAR_IS(var, "GPG_REQUIRE_SIG"))
1543 : : {
1544 : 1 : add_acc_bool(&(curr_acc->gpg_require_sig), val);
1545 : : }
1546 [ + + ]: 103 : else if(CONF_VAR_IS(var, "GPG_DISABLE_SIG"))
1547 : : {
1548 : 2 : add_acc_bool(&(curr_acc->gpg_disable_sig), val);
1549 : : }
1550 [ + + ]: 101 : else if(CONF_VAR_IS(var, "GPG_IGNORE_SIG_VERIFY_ERROR"))
1551 : : {
1552 : 1 : add_acc_bool(&(curr_acc->gpg_ignore_sig_error), val);
1553 : : }
1554 [ + + ]: 100 : else if(CONF_VAR_IS(var, "GPG_REMOTE_ID"))
1555 : : {
1556 [ - + ]: 68 : if(add_acc_string(&(curr_acc->gpg_remote_id), val) != SUCCESS)
1557 : : {
1558 : 0 : fclose(file_ptr);
1559 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1560 : : }
1561 : : }
1562 [ + + ]: 32 : else if(CONF_VAR_IS(var, "GPG_FINGERPRINT_ID"))
1563 : : {
1564 [ - + ]: 3 : if(add_acc_string(&(curr_acc->gpg_remote_fpr), val) != SUCCESS)
1565 : : {
1566 : 0 : fclose(file_ptr);
1567 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1568 : : }
1569 : : }
1570 [ + + ]: 29 : else if(CONF_VAR_IS(var, "ACCESS_EXPIRE"))
1571 : : {
1572 [ + + ]: 3 : if (add_acc_expire_time(opts, &(curr_acc->access_expire_time), val) != 1)
1573 : : {
1574 : 1 : fclose(file_ptr);
1575 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1576 : : }
1577 : : }
1578 [ + + ]: 26 : else if(CONF_VAR_IS(var, "ACCESS_EXPIRE_EPOCH"))
1579 : : {
1580 [ - + ]: 1 : if (add_acc_expire_time_epoch(opts, &(curr_acc->access_expire_time), val) != 1)
1581 : : {
1582 : 0 : fclose(file_ptr);
1583 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1584 : : }
1585 : : }
1586 [ + + ]: 25 : else if(CONF_VAR_IS(var, "FORCE_NAT"))
1587 : : {
1588 : : #if FIREWALL_IPTABLES
1589 [ + + ]: 15 : if(strncasecmp(opts->config[CONF_ENABLE_IPT_FORWARDING], "Y", 1) !=0 )
1590 : : {
1591 : 1 : log_msg(LOG_ERR,
1592 : : "[*] FORCE_NAT requires ENABLE_IPT_FORWARDING to be enabled in fwknopd.conf");
1593 : 1 : fclose(file_ptr);
1594 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1595 : : }
1596 [ + + ]: 14 : if(add_acc_force_nat(opts, curr_acc, val) != SUCCESS)
1597 : : {
1598 : 3 : fclose(file_ptr);
1599 : 3 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1600 : : }
1601 : : #else
1602 : : log_msg(LOG_ERR,
1603 : : "[*] FORCE_NAT not supported.");
1604 : : fclose(file_ptr);
1605 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1606 : : #endif
1607 : : }
1608 [ + + ]: 10 : else if(CONF_VAR_IS(var, "FORCE_SNAT"))
1609 : : {
1610 : : #if FIREWALL_IPTABLES
1611 [ + + ]: 6 : if(strncasecmp(opts->config[CONF_ENABLE_IPT_FORWARDING], "Y", 1) !=0 )
1612 : : {
1613 : 1 : log_msg(LOG_ERR,
1614 : : "[*] FORCE_SNAT requires ENABLE_IPT_FORWARDING to be enabled in fwknopd.conf");
1615 : 1 : fclose(file_ptr);
1616 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1617 : : }
1618 [ + + ]: 5 : if(add_acc_force_snat(opts, curr_acc, val) != SUCCESS)
1619 : : {
1620 : 2 : fclose(file_ptr);
1621 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1622 : : }
1623 : : #else
1624 : : log_msg(LOG_ERR,
1625 : : "[*] FORCE_SNAT not supported.");
1626 : : fclose(file_ptr);
1627 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1628 : : #endif
1629 : : }
1630 [ + + ]: 4 : else if(CONF_VAR_IS(var, "FORCE_MASQUERADE"))
1631 : : {
1632 : 3 : add_acc_bool(&(curr_acc->force_masquerade), val);
1633 : 3 : add_acc_bool(&(curr_acc->force_snat), val);
1634 : : }
1635 : : else
1636 : : {
1637 : 5701 : log_msg(LOG_ERR,
1638 : : "[*] Ignoring unknown access parameter: '%s' in %s",
1639 : : var, opts->config[CONF_ACCESS_FILE]
1640 : : );
1641 : : }
1642 : : }
1643 : :
1644 : 1661 : fclose(file_ptr);
1645 : :
1646 : : /* Basic check to ensure that we got at least one SOURCE stanza with
1647 : : * a valid KEY defined (valid meaning it has a value that is not
1648 : : * "__CHANGEME__".
1649 : : */
1650 [ + + ]: 1661 : if (got_source == 0)
1651 : : {
1652 : 1 : log_msg(LOG_ERR,
1653 : : "[*] Could not find valid SOURCE stanza in access file: '%s'",
1654 : : opts->config[CONF_ACCESS_FILE]);
1655 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1656 : : }
1657 : :
1658 : : /* Sanity check the last stanza
1659 : : */
1660 [ + + ]: 1660 : if(!acc_data_is_valid(curr_acc))
1661 : : {
1662 : 4 : log_msg(LOG_ERR,
1663 : : "[*] Data error in access file: '%s'",
1664 : : opts->config[CONF_ACCESS_FILE]);
1665 : 4 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1666 : : }
1667 : :
1668 : : /* Expand our the expandable fields into their respective data buckets.
1669 : : */
1670 : 1656 : expand_acc_ent_lists(opts);
1671 : :
1672 : : /* Make sure default values are set where needed.
1673 : : */
1674 : 1622 : set_acc_defaults(opts);
1675 : :
1676 : 1621 : return;
1677 : : }
1678 : :
1679 : : int
1680 : 31296 : compare_addr_list(acc_int_list_t *source_list, const uint32_t ip)
1681 : : {
1682 : 31296 : int match = 0;
1683 : :
1684 [ + + ]: 31411 : while(source_list)
1685 : : {
1686 [ + + ]: 31373 : if((ip & source_list->mask) == (source_list->maddr & source_list->mask))
1687 : : {
1688 : : match = 1;
1689 : : break;
1690 : : }
1691 : :
1692 : 115 : source_list = source_list->next;
1693 : : }
1694 : :
1695 : 31296 : return(match);
1696 : : }
1697 : :
1698 : : /* Compare the contents of 2 port lists. Return true on a match.
1699 : : * Match depends on the match_any flag. if match_any is 1 then any
1700 : : * entry in the incoming data need only match one item to return true.
1701 : : * Otherwise all entries in the incoming data must have a corresponding
1702 : : * match in the access port_list.
1703 : : */
1704 : : static int
1705 : 18 : compare_port_list(acc_port_list_t *in, acc_port_list_t *ac, const int match_any)
1706 : : {
1707 : 18 : int a_cnt = 0;
1708 : 18 : int i_cnt = 0;
1709 : :
1710 : : acc_port_list_t *tlist;
1711 [ + + ]: 36 : while(in)
1712 : : {
1713 : 18 : i_cnt++;
1714 : :
1715 : 18 : tlist = ac;
1716 [ + + ]: 70 : while(tlist)
1717 : : {
1718 [ + + ]: 52 : if(in->proto == tlist->proto && in->port == tlist->port)
1719 : : {
1720 : 15 : a_cnt++;
1721 [ + - ]: 15 : if(match_any == 1)
1722 : : return(1);
1723 : : }
1724 : 52 : tlist = tlist->next;
1725 : : }
1726 : 18 : in = in->next;
1727 : : }
1728 : :
1729 : 18 : return(i_cnt == a_cnt);
1730 : : }
1731 : :
1732 : : /* Take a proto/port string (or mulitple comma-separated strings) and check
1733 : : * them against the list for the given access stanza.
1734 : : *
1735 : : * Return 1 if we are allowed
1736 : : */
1737 : : int
1738 : 519 : acc_check_port_access(acc_stanza_t *acc, char *port_str)
1739 : : {
1740 : 519 : int res = 1, ctr = 0;
1741 : :
1742 : 519 : char buf[ACCESS_BUF_LEN] = {0};
1743 : : char *ndx, *start;
1744 : :
1745 : 519 : acc_port_list_t *o_pl = acc->oport_list;
1746 : 519 : acc_port_list_t *r_pl = acc->rport_list;
1747 : :
1748 : 519 : acc_port_list_t *in_pl = NULL;
1749 : :
1750 : 519 : start = port_str;
1751 : :
1752 : : /* Create our own internal port_list from the incoming SPA data
1753 : : * for comparison.
1754 : : */
1755 [ + + ]: 4271 : for(ndx = start; *ndx != '\0'; ndx++)
1756 : : {
1757 [ + + ]: 3752 : if(*ndx == ',')
1758 : : {
1759 [ + - ]: 46 : if((ctr >= ACCESS_BUF_LEN)
1760 [ - + ]: 46 : || (((ndx-start)+1) >= ACCESS_BUF_LEN))
1761 : : {
1762 : 0 : log_msg(LOG_ERR,
1763 : : "[*] Unable to create acc_port_list from incoming data: %s",
1764 : : port_str
1765 : : );
1766 : 0 : free_acc_port_list(in_pl);
1767 : 0 : return(0);
1768 : : }
1769 : 46 : strlcpy(buf, start, (ndx-start)+1);
1770 [ - + ]: 46 : if(add_port_list_ent(&in_pl, buf) == 0)
1771 : : {
1772 : 0 : log_msg(LOG_ERR, "[*] Invalid proto/port string");
1773 : 0 : free_acc_port_list(in_pl);
1774 : 0 : return(0);
1775 : : }
1776 : :
1777 : 46 : start = ndx+1;
1778 : 46 : ctr = 0;
1779 : : }
1780 : 3752 : ctr++;
1781 : : }
1782 [ + - ]: 519 : if((ctr >= ACCESS_BUF_LEN)
1783 [ - + ]: 519 : || (((ndx-start)+1) >= ACCESS_BUF_LEN))
1784 : : {
1785 : 0 : log_msg(LOG_ERR,
1786 : : "[*] Unable to create acc_port_list from incoming data: %s",
1787 : : port_str
1788 : : );
1789 : 0 : free_acc_port_list(in_pl);
1790 : 0 : return(0);
1791 : : }
1792 : 519 : strlcpy(buf, start, (ndx-start)+1);
1793 [ - + ]: 519 : if(add_port_list_ent(&in_pl, buf) == 0)
1794 : : {
1795 : 0 : log_msg(LOG_ERR, "[*] Invalid proto/port string");
1796 : 0 : free_acc_port_list(in_pl);
1797 : 0 : return 0;
1798 : : }
1799 : :
1800 [ - + ]: 519 : if(in_pl == NULL)
1801 : : {
1802 : 0 : log_msg(LOG_ERR,
1803 : : "[*] Unable to create acc_port_list from incoming data: %s", port_str
1804 : : );
1805 : 0 : return(0);
1806 : : }
1807 : :
1808 : : /* Start with restricted ports (if any). Any match (even if only one
1809 : : * entry) means not allowed.
1810 : : */
1811 [ - + ][ # # ]: 519 : if((acc->rport_list != NULL) && (compare_port_list(in_pl, r_pl, 1)))
1812 : : {
1813 : : res = 0;
1814 : : goto cleanup_and_bail;
1815 : : }
1816 : :
1817 : : /* For open port list, all must match.
1818 : : */
1819 [ + + ][ + + ]: 519 : if((acc->oport_list != NULL) && (!compare_port_list(in_pl, o_pl, 0)))
1820 : 3 : res = 0;
1821 : :
1822 : : cleanup_and_bail:
1823 : 519 : free_acc_port_list(in_pl);
1824 : 519 : return(res);
1825 : : }
1826 : :
1827 : : /* Dump the configuration
1828 : : */
1829 : : void
1830 : 1615 : dump_access_list(const fko_srv_options_t *opts)
1831 : : {
1832 : 1615 : int i = 0;
1833 : :
1834 : 1615 : acc_stanza_t *acc = opts->acc_stanzas;
1835 : :
1836 : 1615 : fprintf(stdout, "Current fwknopd access settings:\n");
1837 : :
1838 [ + - ]: 1615 : if(!acc)
1839 : : {
1840 : 0 : fprintf(stderr, "\n ** No Access Settings Defined **\n\n");
1841 : 1615 : return;
1842 : : }
1843 : :
1844 [ + + ]: 3241 : while(acc)
1845 : : {
1846 [ + + ][ + + ]: 1640 : fprintf(stdout,
[ + - ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ - + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ - + ][ + + ]
1847 : : "SOURCE (%i): %s\n"
1848 : : "==============================================================\n"
1849 : : " OPEN_PORTS: %s\n"
1850 : : " RESTRICT_PORTS: %s\n"
1851 : : " KEY: %s\n"
1852 : : " KEY_BASE64: %s\n"
1853 : : " KEY_LEN: %d\n"
1854 : : " HMAC_KEY: %s\n"
1855 : : " HMAC_KEY_BASE64: %s\n"
1856 : : " HMAC_KEY_LEN: %d\n"
1857 : : " HMAC_DIGEST_TYPE: %d\n"
1858 : : " FW_ACCESS_TIMEOUT: %i\n"
1859 : : " ENABLE_CMD_EXEC: %s\n"
1860 : : " CMD_EXEC_USER: %s\n"
1861 : : " REQUIRE_USERNAME: %s\n"
1862 : : " REQUIRE_SOURCE_ADDRESS: %s\n"
1863 : : " FORCE_NAT (ip): %s\n"
1864 : : " FORCE_NAT (proto): %s\n"
1865 : : " FORCE_NAT (port): %d\n"
1866 : : " FORCE_SNAT (ip): %s\n"
1867 : : " FORCE_MASQUERADE: %s\n"
1868 : : " ACCESS_EXPIRE: %s" /* asctime() adds a newline */
1869 : : " GPG_HOME_DIR: %s\n"
1870 : : " GPG_EXE: %s\n"
1871 : : " GPG_DECRYPT_ID: %s\n"
1872 : : " GPG_DECRYPT_PW: %s\n"
1873 : : " GPG_REQUIRE_SIG: %s\n"
1874 : : "GPG_IGNORE_SIG_VERIFY_ERROR: %s\n"
1875 : : " GPG_REMOTE_ID: %s\n"
1876 : : " GPG_FINGERPRINT_ID: %s\n",
1877 : : ++i,
1878 : : acc->source,
1879 : 1626 : (acc->open_ports == NULL) ? "<not set>" : acc->open_ports,
1880 : 1626 : (acc->restrict_ports == NULL) ? "<not set>" : acc->restrict_ports,
1881 : 1626 : (acc->key == NULL) ? "<not set>" : "<see the access.conf file>",
1882 : 1626 : (acc->key_base64 == NULL) ? "<not set>" : "<see the access.conf file>",
1883 : : acc->key_len ? acc->key_len : 0,
1884 : 1626 : (acc->hmac_key == NULL) ? "<not set>" : "<see the access.conf file>",
1885 : 1626 : (acc->hmac_key_base64 == NULL) ? "<not set>" : "<see the access.conf file>",
1886 : : acc->hmac_key_len ? acc->hmac_key_len : 0,
1887 : : acc->hmac_type,
1888 : : acc->fw_access_timeout,
1889 : 1626 : acc->enable_cmd_exec ? "Yes" : "No",
1890 : 1626 : (acc->cmd_exec_user == NULL) ? "<not set>" : acc->cmd_exec_user,
1891 : 1626 : (acc->require_username == NULL) ? "<not set>" : acc->require_username,
1892 : 1626 : acc->require_source_address ? "Yes" : "No",
1893 : : acc->force_nat ? acc->force_nat_ip : "<not set>",
1894 [ - + ]: 11 : acc->force_nat && acc->force_nat_proto != NULL ? acc->force_nat_proto : "<not set>",
1895 : 1626 : acc->force_nat ? acc->force_nat_port : 0,
1896 : 1626 : acc->force_snat ? acc->force_snat_ip : "<not set>",
1897 : 1626 : acc->force_masquerade ? "Yes" : "No",
1898 : 3 : (acc->access_expire_time > 0) ? asctime(localtime(&acc->access_expire_time)) : "<not set>\n",
1899 : 1626 : (acc->gpg_home_dir == NULL) ? "<not set>" : acc->gpg_home_dir,
1900 : 1626 : (acc->gpg_exe == NULL) ? "<not set>" : acc->gpg_exe,
1901 : 1626 : (acc->gpg_decrypt_id == NULL) ? "<not set>" : acc->gpg_decrypt_id,
1902 : 1626 : (acc->gpg_decrypt_pw == NULL) ? "<not set>" : "<see the access.conf file>",
1903 : 1626 : acc->gpg_require_sig ? "Yes" : "No",
1904 : 1626 : acc->gpg_ignore_sig_error ? "Yes" : "No",
1905 : 1626 : (acc->gpg_remote_id == NULL) ? "<not set>" : acc->gpg_remote_id,
1906 : 1626 : (acc->gpg_remote_fpr == NULL) ? "<not set>" : acc->gpg_remote_fpr
1907 : : );
1908 : :
1909 : 1626 : fprintf(stdout, "\n");
1910 : :
1911 : 1626 : acc = acc->next;
1912 : : }
1913 : :
1914 : 1615 : fprintf(stdout, "\n");
1915 : 1615 : fflush(stdout);
1916 : : }
1917 : :
1918 : : /***EOF***/
|
