LCOV - code coverage report
Current view: top level - fwknop.git/server - access.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 624 715 87.3 %
Date: 2014-07-28 Functions: 30 30 100.0 %
Branches: 471 564 83.5 %

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

Generated by: LCOV version 1.9