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