280e702481ec07f72d2d316aaaf485da364777e1
[fwknop.git] / server / access.c
1 /*
2  ******************************************************************************
3  *
4  * File:    access.c
5  *
6  * Author:  Damien Stuart
7  *
8  * Purpose: Access.conf file processing for fwknop server.
9  *
10  * Copyright 2010 Damien Stuart (dstuart@dstuart.org)
11  *
12  *  License (GNU 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 /* Add an access string entry
45 */
46 static void
47 add_acc_string(char **var, const char *val)
48 {
49     if(*var != NULL)
50         free(*var);
51
52     if((*var = strdup(val)) == NULL)
53     {
54         log_msg(LOG_ERR,
55             "Fatal memory allocation error adding access list entry: %s", var
56         );
57         exit(EXIT_FAILURE);
58     }
59 }
60
61 /* Add an access int entry
62 */
63 static int
64 add_acc_int(int *var, const char *val)
65 {
66     return(*var = atoi(val));
67 }
68
69 /* Add an access bool entry (unsigned char of 1 or 0)
70 */
71 static unsigned char
72 add_acc_bool(unsigned char *var, const char *val)
73 {
74     return(*var = (strncasecmp(val, "Y", 1) == 0) ? 1 : 0);
75 }
76
77 /* Add expiration time - convert date to epoch seconds
78 */
79 static void
80 add_acc_expire_time(fko_srv_options_t *opts, time_t *access_expire_time, const char *val)
81 {
82     struct tm tm;
83
84     memset(&tm, 0, sizeof(struct tm));
85
86     if (sscanf(val, "%2d/%2d/%4d", &tm.tm_mon, &tm.tm_mday, &tm.tm_year) != 3)
87     {
88
89         log_msg(LOG_ERR,
90             "Fatal: invalid date value '%s' (need MM/DD/YYYY) for access stanza expiration time",
91             val
92         );
93         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
94     }
95
96     if(tm.tm_mon > 0)
97         tm.tm_mon -= 1;  /* 0-11 */
98
99     /* number of years since 1900
100     */
101     if(tm.tm_year > 1900)
102         tm.tm_year -= 1900;
103     else
104         if(tm.tm_year < 100)
105             tm.tm_year += 100;
106
107     *access_expire_time = mktime(&tm);
108
109     return;
110 }
111
112 /* Add expiration time via epoch seconds defined in access.conf
113 */
114 static void
115 add_acc_expire_time_epoch(fko_srv_options_t *opts, time_t *access_expire_time, const char *val)
116 {
117     char *endptr;
118     unsigned long expire_time = 0;
119
120     errno = 0;
121
122     expire_time = (time_t) strtoul(val, &endptr, 10);
123
124     if (errno == ERANGE || (errno != 0 && expire_time == 0))
125     {
126         log_msg(LOG_ERR,
127             "Fatal: invalid epoch seconds value '%s' for access stanza expiration time",
128             val
129         );
130         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
131     }
132
133     *access_expire_time = (time_t) expire_time;
134
135     return;
136 }
137
138 #if FIREWALL_IPTABLES
139 static void
140 add_acc_force_nat(fko_srv_options_t *opts, acc_stanza_t *curr_acc, const char *val)
141 {
142     char      ip_str[MAX_IPV4_STR_LEN] = {0};
143
144     if (sscanf(val, "%15s %5u", ip_str, &curr_acc->force_nat_port) != 2)
145     {
146
147         log_msg(LOG_ERR,
148             "Fatal: invalid FORCE_NAT arg '%s', need <IP> <PORT>",
149             val
150         );
151         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
152     }
153
154     if (curr_acc->force_nat_port > MAX_PORT)
155     {
156         log_msg(LOG_ERR,
157             "Fatal: invalid FORCE_NAT port '%d'", curr_acc->force_nat_port);
158         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
159     }
160
161     curr_acc->force_nat = 1;
162     add_acc_string(&(curr_acc->force_nat_ip), ip_str);
163
164     return;
165 }
166 #endif
167
168 /* Take an IP or Subnet/Mask and convert it to mask for later
169  * comparisons of incoming source IPs against this mask.
170 */
171 static int
172 add_source_mask(acc_stanza_t *acc, const char *ip)
173 {
174     char                *ndx;
175     char                ip_str[MAX_IPV4_STR_LEN] = {0};
176     uint32_t            mask;
177
178     struct in_addr      in;
179
180     acc_int_list_t      *last_sle, *new_sle, *tmp_sle;
181
182     if((new_sle = calloc(1, sizeof(acc_int_list_t))) == NULL)
183     {
184         log_msg(LOG_ERR,
185             "Fatal memory allocation error adding stanza source_list entry"
186         );
187         exit(EXIT_FAILURE);
188     }
189
190     /* If this is not the first entry, we walk our pointer to the
191      * end of the list.
192     */
193     if(acc->source_list == NULL)
194     {
195         acc->source_list = new_sle;
196     }
197     else
198     {
199         tmp_sle = acc->source_list;
200
201         do {
202             last_sle = tmp_sle;
203         } while((tmp_sle = tmp_sle->next));
204
205         last_sle->next = new_sle;
206     }
207
208     /* Convert the IP data into the appropriate mask
209     */
210     if(strcasecmp(ip, "ANY") == 0)
211     {
212         new_sle->maddr = 0x0;
213         new_sle->mask = 0x0;
214     }
215     else
216     {
217         /* See if we have a subnet component.  If so pull out the IP and
218          * mask values, then create the final mask value.
219         */
220         if((ndx = strchr(ip, '/')) != NULL)
221         {
222             mask = atoi(ndx+1);
223             strlcpy(ip_str, ip, (ndx-ip)+1);
224         }
225         else
226         {
227             mask = 32;
228             strlcpy(ip_str, ip, strlen(ip)+1);
229         }
230
231         if(inet_aton(ip_str, &in) == 0)
232         {
233             log_msg(LOG_ERR,
234                 "Error parsing IP to int for: %s", ip_str
235             );
236
237             free(new_sle);
238             new_sle = NULL;
239
240             return 0;
241         }
242
243         /* Store our mask converted from CIDR to a 32-bit value.
244         */
245         new_sle->mask  = (0xFFFFFFFF << (32 - mask));
246
247         /* Store our masked address for comparisons with future incoming
248          * packets.
249         */
250         new_sle->maddr = ntohl(in.s_addr) & new_sle->mask;
251     }
252     return 1;
253 }
254
255 /* Expand the access SOURCE string to a list of masks.
256 */
257 static int
258 expand_acc_source(acc_stanza_t *acc)
259 {
260     char           *ndx, *start;
261     char            buf[ACCESS_BUF_LEN];
262     int             res = 1;
263
264     start = acc->source;
265
266     for(ndx = start; *ndx; ndx++)
267     {
268         if(*ndx == ',')
269         {
270             /* Skip over any leading whitespace.
271             */
272             while(isspace(*start))
273                 start++;
274
275             if(((ndx-start)+1) >= ACCESS_BUF_LEN)
276                 return 0;
277
278             strlcpy(buf, start, (ndx-start)+1);
279             res = add_source_mask(acc, buf);
280             if(res == 0)
281                 return res;
282             start = ndx+1;
283         }
284     }
285
286     /* Skip over any leading whitespace (once again for the last in the list).
287     */
288     while(isspace(*start))
289         start++;
290
291     if(((ndx-start)+1) >= ACCESS_BUF_LEN)
292         return 0;
293
294     strlcpy(buf, start, (ndx-start)+1);
295     res = add_source_mask(acc, buf);
296
297     return res;
298 }
299
300 static int
301 parse_proto_and_port(char *pstr, int *proto, int *port)
302 {
303     char    *ndx;
304     char    proto_str[ACCESS_BUF_LEN];
305
306     /* Parse the string into its components.
307     */
308     if((ndx = strchr(pstr, '/')) == NULL)
309     {
310         log_msg(LOG_ERR,
311             "Parse error on access port entry: %s", pstr);
312
313         return(-1);
314     }
315
316     if(((ndx - pstr)+1) >= ACCESS_BUF_LEN)
317     {
318         log_msg(LOG_ERR,
319             "Parse error on access port entry: %s", pstr);
320         return(-1);
321     }
322
323     strlcpy(proto_str, pstr, (ndx - pstr)+1);
324
325     *port = atoi(ndx+1);
326
327     if((*port < 0) || (*port > MAX_PORT))
328     {
329         log_msg(LOG_ERR,
330             "Invalid port in access request: %s", pstr);
331         return(-1);
332     }
333
334     if(strcasecmp(proto_str, "tcp") == 0)
335         *proto = PROTO_TCP;
336     else if(strcasecmp(proto_str, "udp") == 0)
337         *proto = PROTO_UDP;
338     else
339     {
340         log_msg(LOG_ERR,
341             "Invalid protocol in access port entry: %s", pstr);
342         return(-1);
343     }
344
345     return(0);
346 }
347
348 /* Take a proto/port string and convert it to appropriate integer values
349  * for comparisons of incoming SPA requests.
350 */
351 static void
352 add_port_list_ent(acc_port_list_t **plist, char *port_str)
353 {
354     int                 proto_int, port;
355
356     acc_port_list_t     *last_plist, *new_plist, *tmp_plist;
357
358     /* Parse the string into its components and continue only if there
359      * are no problems with the incoming string.
360     */
361     if(parse_proto_and_port(port_str, &proto_int, &port) != 0)
362         return;
363
364     if((new_plist = calloc(1, sizeof(acc_port_list_t))) == NULL)
365     {
366         log_msg(LOG_ERR,
367             "Fatal memory allocation error adding stanza source_list entry"
368         );
369         exit(EXIT_FAILURE);
370     }
371
372     /* If this is not the first entry, we walk our pointer to the
373      * end of the list.
374     */
375     if(*plist == NULL)
376     {
377         *plist = new_plist;
378     }
379     else
380     {
381         tmp_plist = *plist;
382
383         do {
384             last_plist = tmp_plist;
385         } while((tmp_plist = tmp_plist->next));
386
387         last_plist->next = new_plist;
388     }
389
390     new_plist->proto = proto_int;
391     new_plist->port  = port;
392 }
393
394 /* Add a string list entry to the given acc_string_list.
395 */
396 static void
397 add_string_list_ent(acc_string_list_t **stlist, const char *str_str)
398 {
399     acc_string_list_t   *last_stlist, *new_stlist, *tmp_stlist;
400
401     if((new_stlist = calloc(1, sizeof(acc_string_list_t))) == NULL)
402     {
403         log_msg(LOG_ERR,
404             "Fatal memory allocation error creating string list entry"
405         );
406         exit(EXIT_FAILURE);
407     }
408
409     /* If this is not the first entry, we walk our pointer to the
410      * end of the list.
411     */
412     if(*stlist == NULL)
413     {
414         *stlist = new_stlist;
415     }
416     else
417     {
418         tmp_stlist = *stlist;
419
420         do {
421             last_stlist = tmp_stlist;
422         } while((tmp_stlist = tmp_stlist->next));
423
424         last_stlist->next = new_stlist;
425     }
426
427     if(new_stlist->str != NULL)
428         free(new_stlist->str);
429
430     new_stlist->str = strdup(str_str);
431
432     if(new_stlist->str == NULL)
433     {
434         log_msg(LOG_ERR,
435             "Fatal memory allocation error adding string list entry item"
436         );
437         exit(EXIT_FAILURE);
438     }
439
440 }
441
442 /* Expand a proto/port access string to a list of access proto-port struct.
443 */
444 int
445 expand_acc_port_list(acc_port_list_t **plist, char *plist_str)
446 {
447     char           *ndx, *start;
448     char            buf[ACCESS_BUF_LEN];
449
450     start = plist_str;
451
452     for(ndx = start; *ndx != '\0'; ndx++)
453     {
454         if(*ndx == ',')
455         {
456             /* Skip over any leading whitespace.
457             */
458             while(isspace(*start))
459                 start++;
460
461             if(((ndx-start)+1) >= ACCESS_BUF_LEN)
462                 return 0;
463
464             strlcpy(buf, start, (ndx-start)+1);
465             add_port_list_ent(plist, buf);
466             start = ndx+1;
467         }
468     }
469
470     /* Skip over any leading whitespace (once again for the last in the list).
471     */
472     while(isspace(*start))
473         start++;
474
475     if(((ndx-start)+1) >= ACCESS_BUF_LEN)
476         return 0;
477
478     strlcpy(buf, start, (ndx-start)+1);
479
480     add_port_list_ent(plist, buf);
481
482     return 1;
483 }
484
485 /* Expand a comma-separated string into a simple acc_string_list.
486 */
487 static void
488 expand_acc_string_list(acc_string_list_t **stlist, char *stlist_str)
489 {
490     char           *ndx, *start;
491     char            buf[1024];
492
493     start = stlist_str;
494
495     for(ndx = start; *ndx; ndx++)
496     {
497         if(*ndx == ',')
498         {
499             /* Skip over any leading whitespace.
500             */
501             while(isspace(*start))
502                 start++;
503
504             strlcpy(buf, start, (ndx-start)+1);
505             add_string_list_ent(stlist, buf);
506             start = ndx+1;
507         }
508     }
509
510     /* Skip over any leading whitespace (once again for the last in the list).
511     */
512     while(isspace(*start))
513         start++;
514
515     strlcpy(buf, start, (ndx-start)+1);
516
517     add_string_list_ent(stlist, buf);
518 }
519
520 /* Free the acc source_list
521 */
522 static void
523 free_acc_source_list(acc_int_list_t *sle)
524 {
525     acc_int_list_t    *last_sle;
526
527     while(sle != NULL)
528     {
529         last_sle = sle;
530         sle = last_sle->next;
531
532         free(last_sle);
533     }
534 }
535
536 /* Free a port_list
537 */
538 void
539 free_acc_port_list(acc_port_list_t *ple)
540 {
541     acc_port_list_t    *last_ple;
542
543     while(ple != NULL)
544     {
545         last_ple = ple;
546         ple = last_ple->next;
547
548         free(last_ple);
549     }
550 }
551
552 /* Free a string_list
553 */
554 static void
555 free_acc_string_list(acc_string_list_t *stl)
556 {
557     acc_string_list_t    *last_stl;
558
559     while(stl != NULL)
560     {
561         last_stl = stl;
562         stl = last_stl->next;
563
564         free(last_stl->str);
565         free(last_stl);
566     }
567 }
568
569 /* Free any allocated content of an access stanza.
570  *
571  * NOTE: If a new access.conf parameter is created, and it is a string
572  *       value, it also needs to be added to the list of items to check
573  *       and free below.
574 */
575 static void
576 free_acc_stanza_data(acc_stanza_t *acc)
577 {
578
579     if(acc->source != NULL)
580     {
581         free(acc->source);
582         free_acc_source_list(acc->source_list);
583     }
584
585     if(acc->open_ports != NULL)
586     {
587         free(acc->open_ports);
588         free_acc_port_list(acc->oport_list);
589     }
590
591     if(acc->restrict_ports != NULL)
592     {
593         free(acc->restrict_ports);
594         free_acc_port_list(acc->rport_list);
595     }
596
597     if(acc->force_nat_ip != NULL)
598         free(acc->force_nat_ip);
599
600     if(acc->key != NULL)
601         free(acc->key);
602
603     if(acc->cmd_exec_user != NULL)
604         free(acc->cmd_exec_user);
605
606     if(acc->require_username != NULL)
607         free(acc->require_username);
608
609     if(acc->gpg_home_dir != NULL)
610         free(acc->gpg_home_dir);
611
612     if(acc->gpg_decrypt_id != NULL)
613         free(acc->gpg_decrypt_id);
614
615     if(acc->gpg_decrypt_pw != NULL)
616         free(acc->gpg_decrypt_pw);
617
618     if(acc->gpg_remote_id != NULL)
619     {
620         free(acc->gpg_remote_id);
621         free_acc_string_list(acc->gpg_remote_id_list);
622     }
623 }
624
625 /* Expand any access entries that may be multi-value.
626 */
627 static void
628 expand_acc_ent_lists(fko_srv_options_t *opts)
629 {
630     acc_stanza_t   *acc = opts->acc_stanzas;
631
632     /* We need to do this for each stanza.
633     */
634     while(acc)
635     {
636         /* Expand the source string to 32-bit integer masks foreach entry.
637         */
638         if(expand_acc_source(acc) == 0)
639         {
640             acc = acc->next;
641             continue;
642         }
643
644         /* Now expand the open_ports string.
645         */
646         if(acc->open_ports != NULL && strlen(acc->open_ports))
647             expand_acc_port_list(&(acc->oport_list), acc->open_ports);
648
649         if(acc->restrict_ports != NULL && strlen(acc->restrict_ports))
650             expand_acc_port_list(&(acc->rport_list), acc->restrict_ports);
651
652         /* Expand the GPG_REMOTE_ID string.
653         */
654         if(acc->gpg_remote_id != NULL && strlen(acc->gpg_remote_id))
655             expand_acc_string_list(&(acc->gpg_remote_id_list), acc->gpg_remote_id);
656
657         acc = acc->next;
658     }
659 }
660
661 void
662 free_acc_stanzas(fko_srv_options_t *opts)
663 {
664     acc_stanza_t    *acc, *last_acc;
665
666     /* Free any resources first (in case of reconfig). Assume non-NULL
667      * entry needs to be freed.
668     */
669     acc = opts->acc_stanzas;
670
671     while(acc != NULL)
672     {
673         last_acc = acc;
674         acc = last_acc->next;
675
676         free_acc_stanza_data(last_acc);
677         free(last_acc);
678     }
679
680     return;
681 }
682
683 /* Wrapper for free_acc_stanzas(), we may put additional initialization
684  * code here.
685 */
686 static void
687 acc_stanza_init(fko_srv_options_t *opts)
688 {
689     /* Free any resources first (in case of reconfig). Assume non-NULL
690      * entry needs to be freed.
691     */
692     free_acc_stanzas(opts);
693
694     return;
695 }
696
697 /* Add a new stanza bay allocating the required memory at the required
698  * location, yada-yada-yada.
699 */
700 static acc_stanza_t*
701 acc_stanza_add(fko_srv_options_t *opts)
702 {
703     acc_stanza_t    *acc     = opts->acc_stanzas;
704     acc_stanza_t    *new_acc = calloc(1, sizeof(acc_stanza_t));
705     acc_stanza_t    *last_acc;
706
707     if(new_acc == NULL)
708     {
709         log_msg(LOG_ERR,
710             "Fatal memory allocation error adding access stanza"
711         );
712         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
713     }
714
715     /* If this is not the first acc entry, we walk our acc pointer to the
716      * end of the existing list.
717     */
718     if(acc == NULL)
719     {
720         opts->acc_stanzas = new_acc;
721     }
722     else
723     {
724         do {
725             last_acc = acc;
726         } while((acc = acc->next));
727
728         last_acc->next = new_acc;
729     }
730
731     return(new_acc);
732 }
733
734 /* Scan the access options for entries that have not bees set, but need
735  * a default value.
736 */
737 static void
738 set_acc_defaults(fko_srv_options_t *opts)
739 {
740     acc_stanza_t    *acc = opts->acc_stanzas;
741
742     if(!acc)
743         return;
744
745     while(acc)
746     {
747         /* set default fw_access_timeout if necessary
748         */
749         if(acc->fw_access_timeout < 1)
750             acc->fw_access_timeout = DEF_FW_ACCESS_TIMEOUT;
751
752         /* set default gpg keyring path if necessary
753         */
754         if(acc->gpg_decrypt_pw != NULL && acc->gpg_home_dir == NULL)
755             add_acc_string(&(acc->gpg_home_dir), opts->config[CONF_GPG_HOME_DIR]);
756
757         acc = acc->next;
758     }
759 }
760
761 /* Perform some sanity checks on an acc stanza data.
762 */
763 static int
764 acc_data_is_valid(const acc_stanza_t *acc)
765 {
766     if(((acc->key == NULL || !strlen(acc->key))
767       && (acc->gpg_decrypt_pw == NULL || !strlen(acc->gpg_decrypt_pw)))
768       || (acc->use_rijndael == 0 && acc->use_gpg == 0 && acc->gpg_allow_no_pw == 0))
769     {
770         fprintf(stderr,
771             "[*] No keys found for access stanza source: '%s'\n", acc->source
772         );
773         return(0);
774     }
775
776     return(1);
777 }
778
779 /* Read and parse the access file, popluating the access data as we go.
780 */
781 void
782 parse_access_file(fko_srv_options_t *opts)
783 {
784     FILE           *file_ptr;
785     char           *ndx;
786     int             got_source = 0;
787     unsigned int    num_lines = 0;
788
789     char            access_line_buf[MAX_LINE_LEN] = {0};
790     char            var[MAX_LINE_LEN]  = {0};
791     char            val[MAX_LINE_LEN]  = {0};
792
793     struct passwd  *pw;
794     struct stat     st;
795
796     acc_stanza_t   *curr_acc = NULL;
797
798     /* First see if the access file exists.  If it doesn't, complain
799      * and bail.
800     */
801     if(stat(opts->config[CONF_ACCESS_FILE], &st) != 0)
802     {
803         fprintf(stderr, "[*] Access file: '%s' was not found.\n",
804             opts->config[CONF_ACCESS_FILE]);
805
806         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
807     }
808
809     verify_file_perms_ownership(opts->config[CONF_ACCESS_FILE]);
810
811     if ((file_ptr = fopen(opts->config[CONF_ACCESS_FILE], "r")) == NULL)
812     {
813         fprintf(stderr, "[*] Could not open access file: %s\n",
814             opts->config[CONF_ACCESS_FILE]);
815         perror(NULL);
816
817         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
818     }
819
820     /* Initialize the access list.
821     */
822     acc_stanza_init(opts);
823
824     /* Now walk through access file pulling the access entries into the
825      * current stanza.
826     */
827     while ((fgets(access_line_buf, MAX_LINE_LEN, file_ptr)) != NULL)
828     {
829         num_lines++;
830         access_line_buf[MAX_LINE_LEN-1] = '\0';
831
832         /* Get past comments and empty lines (note: we only look at the
833          * first character.
834         */
835         if(IS_EMPTY_LINE(access_line_buf[0]))
836             continue;
837
838         if(sscanf(access_line_buf, "%s %[^;\n\r]", var, val) != 2)
839         {
840             fprintf(stderr,
841                 "*Invalid access file entry in %s at line %i.\n - '%s'",
842                 opts->config[CONF_ACCESS_FILE], num_lines, access_line_buf
843             );
844             continue;
845         }
846
847         /* Remove any colon that may be on the end of the var
848         */
849         if((ndx = strrchr(var, ':')) != NULL)
850             *ndx = '\0';
851
852         /*
853         */
854         if(opts->verbose > 3)
855             fprintf(stderr,
856                 "ACCESS FILE: %s, LINE: %s\tVar: %s, Val: '%s'\n",
857                 opts->config[CONF_ACCESS_FILE], access_line_buf, var, val
858             );
859
860         /* Process the entry.
861          *
862          * NOTE: If a new access.conf parameter is created.  It also needs
863          *       to be accounted for in the following if/if else construct.
864         */
865
866         if(CONF_VAR_IS(var, "SOURCE"))
867         {
868             /* If this is not the first stanza, sanity check the previous
869              * stanza for the minimum required data.
870             */
871             if(curr_acc != NULL) {
872                 if(!acc_data_is_valid(curr_acc))
873                 {
874                     fprintf(stderr,
875                         "[*] Data error in access file: '%s'\n",
876                         opts->config[CONF_ACCESS_FILE]);
877                     clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
878                 }
879             }
880
881             /* Start new stanza.
882             */
883             curr_acc = acc_stanza_add(opts);
884
885             add_acc_string(&(curr_acc->source), val);
886
887             got_source++;
888         }
889         else if (curr_acc == NULL)
890         {
891             /* The stanza must start with the "SOURCE" variable
892             */
893             continue;
894         }
895         else if(CONF_VAR_IS(var, "OPEN_PORTS"))
896         {
897             add_acc_string(&(curr_acc->open_ports), val);
898         }
899         else if(CONF_VAR_IS(var, "RESTRICT_PORTS"))
900         {
901             add_acc_string(&(curr_acc->restrict_ports), val);
902         }
903         else if(CONF_VAR_IS(var, "KEY"))
904         {
905             if(strcasecmp(val, "__CHANGEME__") == 0)
906             {
907                 fprintf(stderr,
908                     "[*] KEY value is not properly set in stanza source '%s' in access file: '%s'\n",
909                     curr_acc->source, opts->config[CONF_ACCESS_FILE]);
910                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
911             }
912             add_acc_string(&(curr_acc->key), val);
913             add_acc_bool(&(curr_acc->use_rijndael), "Y");
914         }
915         else if(CONF_VAR_IS(var, "FW_ACCESS_TIMEOUT"))
916         {
917             add_acc_int(&(curr_acc->fw_access_timeout), val);
918         }
919         else if(CONF_VAR_IS(var, "ENABLE_CMD_EXEC"))
920         {
921             add_acc_bool(&(curr_acc->enable_cmd_exec), val);
922         }
923         else if(CONF_VAR_IS(var, "CMD_EXEC_USER"))
924         {
925             add_acc_string(&(curr_acc->cmd_exec_user), val);
926
927             errno = 0;
928             pw = getpwnam(val);
929
930             if(pw == NULL)
931             {
932                 fprintf(stderr, "Unable to determine UID for CMD_EXEC_USER: %s.\n",
933                     errno ? strerror(errno) : "Not a user on this system");
934                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
935             }
936
937             curr_acc->cmd_exec_uid = pw->pw_uid;
938         }
939         else if(CONF_VAR_IS(var, "REQUIRE_USERNAME"))
940         {
941             add_acc_string(&(curr_acc->require_username), val);
942         }
943         else if(CONF_VAR_IS(var, "REQUIRE_SOURCE_ADDRESS"))
944         {
945             add_acc_bool(&(curr_acc->require_source_address), val);
946         }
947         else if(CONF_VAR_IS(var, "REQUIRE_SOURCE"))  /* synonym for REQUIRE_SOURCE_ADDRESS */
948         {
949             add_acc_bool(&(curr_acc->require_source_address), val);
950         }
951         else if(CONF_VAR_IS(var, "GPG_HOME_DIR"))
952         {
953             if (is_valid_dir(val))
954             {
955                 add_acc_string(&(curr_acc->gpg_home_dir), val);
956             }
957             else
958             {
959                 fprintf(stderr,
960                     "[*] GPG_HOME_DIR directory '%s' stat()/existence problem in stanza source '%s' in access file: '%s'\n",
961                     val, curr_acc->source, opts->config[CONF_ACCESS_FILE]);
962                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
963             }
964         }
965         else if(CONF_VAR_IS(var, "GPG_DECRYPT_ID"))
966         {
967             add_acc_string(&(curr_acc->gpg_decrypt_id), val);
968         }
969         else if(CONF_VAR_IS(var, "GPG_DECRYPT_PW"))
970         {
971             if(strcasecmp(val, "__CHANGEME__") == 0)
972             {
973                 fprintf(stderr,
974                     "[*] GPG_DECRYPT_PW value is not properly set in stanza source '%s' in access file: '%s'\n",
975                     curr_acc->source, opts->config[CONF_ACCESS_FILE]);
976                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
977             }
978             add_acc_string(&(curr_acc->gpg_decrypt_pw), val);
979             add_acc_bool(&(curr_acc->use_gpg), "Y");
980         }
981         else if(CONF_VAR_IS(var, "GPG_ALLOW_NO_PW"))
982         {
983             add_acc_bool(&(curr_acc->gpg_allow_no_pw), val);
984             if(curr_acc->gpg_allow_no_pw == 1)
985             {
986                 add_acc_bool(&(curr_acc->use_gpg), "Y");
987                 if(curr_acc->gpg_decrypt_pw != NULL && curr_acc->gpg_decrypt_pw[0] != '\0')
988                     free(curr_acc->gpg_decrypt_pw);
989                 add_acc_string(&(curr_acc->gpg_decrypt_pw), "");
990             }
991         }
992         else if(CONF_VAR_IS(var, "GPG_REQUIRE_SIG"))
993         {
994             add_acc_bool(&(curr_acc->gpg_require_sig), val);
995         }
996         else if(CONF_VAR_IS(var, "GPG_IGNORE_SIG_VERIFY_ERROR"))
997         {
998             add_acc_bool(&(curr_acc->gpg_ignore_sig_error), val);
999         }
1000         else if(CONF_VAR_IS(var, "GPG_REMOTE_ID"))
1001         {
1002             add_acc_string(&(curr_acc->gpg_remote_id), val);
1003         }
1004         else if(CONF_VAR_IS(var, "ACCESS_EXPIRE"))
1005         {
1006             add_acc_expire_time(opts, &(curr_acc->access_expire_time), val);
1007         }
1008         else if(CONF_VAR_IS(var, "ACCESS_EXPIRE_EPOCH"))
1009         {
1010             add_acc_expire_time_epoch(opts, &(curr_acc->access_expire_time), val);
1011         }
1012         else if(CONF_VAR_IS(var, "FORCE_NAT"))
1013         {
1014 #if FIREWALL_IPTABLES
1015             if(strncasecmp(opts->config[CONF_ENABLE_IPT_FORWARDING], "Y", 1) !=0 )
1016             {
1017                 fprintf(stderr,
1018                     "[*] FORCE_NAT requires ENABLE_IPT_FORWARDING to be enabled in fwknopd.conf\n");
1019                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1020             }
1021             add_acc_force_nat(opts, curr_acc, val);
1022 #else
1023             fprintf(stderr,
1024                 "[*] FORCE_NAT not supported.\n");
1025             clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1026 #endif
1027         }
1028         else
1029         {
1030             fprintf(stderr,
1031                 "*Ignoring unknown access parameter: '%s' in %s\n",
1032                 var, opts->config[CONF_ACCESS_FILE]
1033             );
1034         }
1035     }
1036
1037     fclose(file_ptr);
1038
1039     /* Basic check to ensure that we got at least one SOURCE stanza with
1040      * a valid KEY defined (valid meaning it has a value that is not
1041      * "__CHANGEME__".
1042     */
1043     if (got_source == 0)
1044     {
1045         fprintf(stderr,
1046             "[*] Could not find valid SOURCE stanza in access file: '%s'\n",
1047             opts->config[CONF_ACCESS_FILE]);
1048         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1049     }
1050
1051     /* Sanity check the last stanza
1052     */
1053     if(!acc_data_is_valid(curr_acc))
1054     {
1055         fprintf(stderr,
1056             "[*] Data error in access file: '%s'\n",
1057             opts->config[CONF_ACCESS_FILE]);
1058         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1059     }
1060
1061     /* Expand our the expandable fields into their respective data buckets.
1062     */
1063
1064     expand_acc_ent_lists(opts);
1065
1066     /* Make sure default values are set where needed.
1067      * a default value.
1068     */
1069     set_acc_defaults(opts);
1070
1071     return;
1072 }
1073
1074 int
1075 compare_addr_list(acc_int_list_t *source_list, const uint32_t ip)
1076 {
1077     int match = 0;
1078
1079     while(source_list)
1080     {
1081         if((ip & source_list->mask) == (source_list->maddr & source_list->mask))
1082         {
1083             match = 1;
1084             break;
1085         }
1086
1087         source_list = source_list->next;
1088     }
1089
1090     return(match);
1091 }
1092
1093 /* Compare the contents of 2 port lists.  Return true on a match.
1094  * Match depends on the match_any flag.  if match_any is 1 then any
1095  * entry in the incoming data need only match one item to return true.
1096  * Otherwise all entries in the incoming data must have a corresponding
1097  * match in the access port_list.
1098 */
1099 static int
1100 compare_port_list(acc_port_list_t *in, acc_port_list_t *ac, const int match_any)
1101 {
1102     int a_cnt = 0;
1103     int i_cnt = 0;
1104
1105     acc_port_list_t *tlist;
1106     while(in)
1107     {
1108         i_cnt++;
1109
1110         tlist = ac;
1111         while(tlist)
1112         {
1113             if(in->proto == tlist->proto && in->port == tlist->port)
1114             {
1115                 a_cnt++;
1116                 if(match_any == 1)
1117                     return(1);
1118             }
1119             tlist = tlist->next;
1120         }
1121         in = in->next;
1122     }
1123
1124     return(i_cnt == a_cnt);
1125 }
1126
1127 /* Take a proto/port string (or mulitple comma-separated strings) and check
1128  * them against the list for the given access stanza.
1129  *
1130  * Return 1 if we are allowed
1131 */
1132 int
1133 acc_check_port_access(acc_stanza_t *acc, char *port_str)
1134 {
1135     int             res = 1, ctr = 0;
1136
1137     char            buf[ACCESS_BUF_LEN];
1138     char           *ndx, *start;
1139
1140     acc_port_list_t *o_pl   = acc->oport_list;
1141     acc_port_list_t *r_pl   = acc->rport_list;
1142
1143     acc_port_list_t *in_pl  = NULL;
1144
1145     start = port_str;
1146
1147     /* Create our own internal port_list from the incoming SPA data
1148      * for comparison.
1149     */
1150     for(ndx = start; *ndx != '\0'; ndx++)
1151     {
1152         if(*ndx == ',')
1153         {
1154             if((ctr >= ACCESS_BUF_LEN)
1155                     || (((ndx-start)+1) >= ACCESS_BUF_LEN))
1156             {
1157                 log_msg(LOG_ERR,
1158                     "Unable to create acc_port_list from incoming data: %s",
1159                     port_str
1160                 );
1161                 return(0);
1162             }
1163             strlcpy(buf, start, (ndx-start)+1);
1164             add_port_list_ent(&in_pl, buf);
1165             start = ndx+1;
1166             ctr = 0;
1167         }
1168         ctr++;
1169     }
1170     if((ctr >= ACCESS_BUF_LEN)
1171             || (((ndx-start)+1) >= ACCESS_BUF_LEN))
1172     {
1173         log_msg(LOG_ERR,
1174             "Unable to create acc_port_list from incoming data: %s",
1175             port_str
1176         );
1177         return(0);
1178     }
1179     strlcpy(buf, start, (ndx-start)+1);
1180     add_port_list_ent(&in_pl, buf);
1181
1182     if(in_pl == NULL)
1183     {
1184         log_msg(LOG_ERR,
1185             "Unable to create acc_port_list from incoming data: %s", port_str
1186         );
1187         return(0);
1188     }
1189
1190     /* Start with restricted ports (if any).  Any match (even if only one
1191      * entry) means not allowed.
1192     */
1193     if((acc->rport_list != NULL) && (compare_port_list(in_pl, r_pl, 1)))
1194     {
1195         res = 0;
1196         goto cleanup_and_bail;
1197     }
1198
1199     /* For open port list, all must match.
1200     */
1201     if((acc->oport_list != NULL) && (!compare_port_list(in_pl, o_pl, 0)))
1202             res = 0;
1203
1204 cleanup_and_bail:
1205     free_acc_port_list(in_pl);
1206     return(res);
1207 }
1208
1209 /* Take a GPG ID string and check it against the list of allowed
1210  * GPG_REMOTE_ID's.
1211  *
1212  * Return 1 if we are allowed
1213 */
1214 int
1215 acc_check_gpg_remote_id(acc_stanza_t *acc, const char *gpg_id)
1216 {
1217     acc_string_list_t *ndx;
1218
1219     for(ndx = acc->gpg_remote_id_list; ndx != NULL; ndx=ndx->next)
1220         if(strcasecmp(ndx->str, gpg_id) == 0)
1221             return(1);
1222
1223     return(0);
1224 }
1225
1226 /* Dump the configuration
1227 */
1228 void
1229 dump_access_list(const fko_srv_options_t *opts)
1230 {
1231     int             i = 0;
1232
1233     acc_stanza_t    *acc = opts->acc_stanzas;
1234
1235     fprintf(stdout, "Current fwknopd access settings:\n");
1236
1237     if(!acc)
1238     {
1239         fprintf(stderr, "\n    ** No Access Settings Defined **\n\n");
1240         return;
1241     }
1242
1243     while(acc)
1244     {
1245         fprintf(stdout,
1246             "SOURCE (%i):  %s\n"
1247             "==============================================================\n"
1248             "                 OPEN_PORTS:  %s\n"
1249             "             RESTRICT_PORTS:  %s\n"
1250             "                        KEY:  <see the access.conf file>\n"
1251             "          FW_ACCESS_TIMEOUT:  %i\n"
1252             "            ENABLE_CMD_EXEC:  %s\n"
1253             "              CMD_EXEC_USER:  %s\n"
1254             "           REQUIRE_USERNAME:  %s\n"
1255             "     REQUIRE_SOURCE_ADDRESS:  %s\n"
1256             "             FORCE_NAT (ip):  %s\n"
1257             "          FORCE_NAT (proto):  %s\n"
1258             "           FORCE_NAT (port):  %d\n"
1259             "              ACCESS_EXPIRE:  %s"  /* asctime() adds a newline */
1260             "               GPG_HOME_DIR:  %s\n"
1261             "             GPG_DECRYPT_ID:  %s\n"
1262             "             GPG_DECRYPT_PW:  <see the access.conf file>\n"
1263             "            GPG_REQUIRE_SIG:  %s\n"
1264             "GPG_IGNORE_SIG_VERIFY_ERROR:  %s\n"
1265             "              GPG_REMOTE_ID:  %s\n",
1266             ++i,
1267             acc->source,
1268             (acc->open_ports == NULL) ? "<not set>" : acc->open_ports,
1269             (acc->restrict_ports == NULL) ? "<not set>" : acc->restrict_ports,
1270             //(acc->key == NULL) ? "<not set>" : acc->key,
1271             acc->fw_access_timeout,
1272             acc->enable_cmd_exec ? "Yes" : "No",
1273             (acc->cmd_exec_user == NULL) ? "<not set>" : acc->cmd_exec_user,
1274             (acc->require_username == NULL) ? "<not set>" : acc->require_username,
1275             acc->require_source_address ? "Yes" : "No",
1276             acc->force_nat ? acc->force_nat_ip : "<not set>",
1277             acc->force_nat && acc->force_nat_proto != NULL ? acc->force_nat_proto : "<not set>",
1278             acc->force_nat ? acc->force_nat_port : 0,
1279             (acc->access_expire_time > 0) ? asctime(localtime(&acc->access_expire_time)) : "<not set>\n",
1280             (acc->gpg_home_dir == NULL) ? "<not set>" : acc->gpg_home_dir,
1281             (acc->gpg_decrypt_id == NULL) ? "<not set>" : acc->gpg_decrypt_id,
1282             //(acc->gpg_decrypt_pw == NULL) ? "<not set>" : acc->gpg_decrypt_pw,
1283             acc->gpg_require_sig ? "Yes" : "No",
1284             acc->gpg_ignore_sig_error  ? "Yes" : "No",
1285             (acc->gpg_remote_id == NULL) ? "<not set>" : acc->gpg_remote_id
1286         );
1287
1288         fprintf(stdout, "\n");
1289
1290         acc = acc->next;
1291     }
1292
1293     fprintf(stdout, "\n");
1294     fflush(stdout);
1295 }
1296
1297 /***EOF***/