Flawfinder version 2.0.10, (C) 2001-2019 David A. Wheeler.
Number of rules (primarily dangerous function names) in C/C++ ruleset: 223
Examining data/unhide-20130526/unhide-tcp-simple-check.c
Examining data/unhide-20130526/unhide-tcp.c
Examining data/unhide-20130526/unhide-output.h
Examining data/unhide-20130526/unhide-output.c
Examining data/unhide-20130526/unhide-linux.h
Examining data/unhide-20130526/unhide-linux-procfs.c
Examining data/unhide-20130526/unhide-tcp-fast.c
Examining data/unhide-20130526/unhide_rb.c
Examining data/unhide-20130526/unhide-linux.c
Examining data/unhide-20130526/unhide-linux-compound.c
Examining data/unhide-20130526/unhide-linux-syscall.c
Examining data/unhide-20130526/unhide-tcp.h
Examining data/unhide-20130526/unhide-posix.c
Examining data/unhide-20130526/unhide-linux-bruteforce.c

FINAL RESULTS:

data/unhide-20130526/unhide-linux.c:319:19:  [5] (race) readlink:
  This accepts filename arguments; if an attacker can move those files or
  change the link content, a race condition results. Also, it does not
  terminate with ASCII NUL. (CWE-362, CWE-20). Reconsider approach.
         length = readlink(cmd, cmdcont, 1000) ;
data/unhide-20130526/unhide_rb.c:168:25:  [5] (race) readlink:
  This accepts filename arguments; if an attacker can move those files or
  change the link content, a race condition results. Also, it does not
  terminate with ASCII NUL. (CWE-362, CWE-20). Reconsider approach.
               length = readlink(myexe, cmdcont, 1000) ;
data/unhide-20130526/unhide_rb.c:310:19:  [5] (race) readlink:
  This accepts filename arguments; if an attacker can move those files or
  change the link content, a race condition results. Also, it does not
  terminate with ASCII NUL. (CWE-362, CWE-20). Reconsider approach.
         length = readlink(mypath, cmdcont, 1000) ;
data/unhide-20130526/unhide-linux-compound.c:210:4:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
   sprintf(command,REVERSE) ;
data/unhide-20130526/unhide-linux-compound.c:212:13:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   fich_tmp=popen (command, "r") ;
data/unhide-20130526/unhide-linux-compound.c:267:7:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
      strcpy(&directory[6],lwp);
data/unhide-20130526/unhide-linux-procfs.c:183:16:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
               sprintf(new_directory,"/proc/%s/task/%d", tmp_pids, procpids) ;
data/unhide-20130526/unhide-linux-procfs.c:314:16:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
               sprintf(new_directory,"/proc/%s/task/%d", tmp_pids, procpids) ;
data/unhide-20130526/unhide-linux-procfs.c:395:7:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
      sprintf(&task[6], "%s/task", directory) ;
data/unhide-20130526/unhide-linux-syscall.c:474:17:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   fich_proceso=popen (SYS_COMMAND, "r") ;
data/unhide-20130526/unhide-linux-syscall.c:552:17:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   fich_proceso=popen (SYS_COMMAND, "r") ;
data/unhide-20130526/unhide-linux-syscall.c:632:30:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   if (NULL != (fich_proceso=popen (SYS_COMMAND, "r"))) 
data/unhide-20130526/unhide-linux-syscall.c:703:30:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   if (NULL != (fich_proceso=popen (SYS_COMMAND, "r"))) 
data/unhide-20130526/unhide-linux.c:139:7:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
      sprintf(command,COMMAND,tmppid) ;
data/unhide-20130526/unhide-linux.c:141:16:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
      fich_tmp=popen (command, "r") ;
data/unhide-20130526/unhide-linux.c:175:19:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
      fich_thread=popen (THREADS, "r") ;
data/unhide-20130526/unhide-linux.c:206:7:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
      sprintf(command,SESSION,tmppid) ;
data/unhide-20130526/unhide-linux.c:208:20:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
      fich_session=popen (command, "r") ;
data/unhide-20130526/unhide-linux.c:240:17:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
      fich_pgid=popen (PGID, "r") ;
data/unhide-20130526/unhide-linux.c:388:19:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
         fich_tmp=popen (cmd, "r") ;
data/unhide-20130526/unhide-linux.c:407:19:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
         fich_tmp=popen (cmd, "r") ;
data/unhide-20130526/unhide-linux.c:726:4:  [4] (format) printf:
  If format strings can be influenced by an attacker, they can be exploited
  (CWE-134). Use a constant for the format specification.
   printf(header) ;
data/unhide-20130526/unhide-output.c:41:4:  [4] (format) vsnprintf:
  If format strings can be influenced by an attacker, they can be exploited,
  and note that sprintf variations do not always \0-terminate (CWE-134). Use
  a constant for the format specification.
   vsnprintf(buf, BUFSIZ, fmt, ap);
data/unhide-20130526/unhide-output.c:153:4:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
   sprintf(filename, "%s_%4d-%02d-%02d.%s", basename, tmPtr->tm_year+1900, tmPtr->tm_mon + 1, tmPtr->tm_mday, "log"  );
data/unhide-20130526/unhide-posix.c:82:11:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
	fich_tmp=popen (COMMAND, "r") ;
data/unhide-20130526/unhide-tcp-fast.c:57:10:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
      fp=popen (tcpcommand1, "r");
data/unhide-20130526/unhide-tcp-fast.c:61:10:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
      fp=popen (udpcommand1, "r");
data/unhide-20130526/unhide-tcp-simple-check.c:103:4:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
   sprintf(buffer, command_fmt, port);
data/unhide-20130526/unhide-tcp-simple-check.c:104:9:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   fp = popen(buffer, "r") ;
data/unhide-20130526/unhide-tcp-simple-check.c:165:26:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   if (NULL != (fich_tmp=popen (command, "r")))
data/unhide-20130526/unhide-tcp-simple-check.c:214:19:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
                  sprintf(tcpcommand, tcpcommand2, i) ;
data/unhide-20130526/unhide-tcp-simple-check.c:234:19:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
                  sprintf(tcpcommand, tcpcommand2, i) ;
data/unhide-20130526/unhide-tcp-simple-check.c:284:19:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
                  sprintf(udpcommand, udpcommand2, u) ;
data/unhide-20130526/unhide-tcp-simple-check.c:440:4:  [4] (format) printf:
  If format strings can be influenced by an attacker, they can be exploited
  (CWE-134). Use a constant for the format specification.
   printf(header) ;
data/unhide-20130526/unhide-tcp.c:120:4:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
   sprintf(buffer, command_fmt, port);
data/unhide-20130526/unhide-tcp.c:121:9:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   fp = popen(buffer, "r") ;
data/unhide-20130526/unhide-tcp.c:190:26:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   if (NULL != (fich_tmp=popen (command, "r")))
data/unhide-20130526/unhide-tcp.c:232:19:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
                  sprintf(tcpcommand, tcpcommand2, i) ;
data/unhide-20130526/unhide-tcp.c:261:19:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
                  sprintf(tcpcommand, tcpcommand2, i) ;
data/unhide-20130526/unhide-tcp.c:325:19:  [4] (format) sprintf:
  Potential format string problem (CWE-134). Make format string constant.
                  sprintf(udpcommand, udpcommand2, u) ;
data/unhide-20130526/unhide-tcp.c:494:4:  [4] (format) printf:
  If format strings can be influenced by an attacker, they can be exploited
  (CWE-134). Use a constant for the format specification.
   printf(header) ;
data/unhide-20130526/unhide_rb.c:125:10:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
         sprintf(&mypath[6],"%s/status",directory);
data/unhide-20130526/unhide_rb.c:145:10:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
         sprintf(&mypath[6],"%s/task/", directory) ;
data/unhide-20130526/unhide_rb.c:165:16:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
               sprintf(myexe,"%s%s/exe",mypath,directory);
data/unhide-20130526/unhide_rb.c:175:22:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
                     strcpy(proc_tasks[strtol(directory, NULL, 10)],cmdcont) ;
data/unhide-20130526/unhide_rb.c:197:13:  [4] (shell) popen:
  This causes a new program to execute and is difficult to use safely
  (CWE-78). try using a library call that implements the same functionality
  if available.
   fich_tmp=popen (UNHIDE_RB, "r") ;
data/unhide-20130526/unhide_rb.c:235:19:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
                  strcpy(ps_pids[mypid],myline+5) ;
data/unhide-20130526/unhide_rb.c:315:13:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
            strcpy(proc_exe,cmdcont) ;
data/unhide-20130526/unhide_rb.c:443:22:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
                     strcpy(description, ps_pids[my_pid]) ;
data/unhide-20130526/unhide_rb.c:450:22:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
                     strcpy(description, proc_tasks[my_pid]) ;
data/unhide-20130526/unhide_rb.c:456:19:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
                  strcpy(description, proc_exe) ;
data/unhide-20130526/unhide_rb.c:459:13:  [4] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf.
            sprintf(scratch, "\n  %s %s%s", (pid_exists[index] ? "Seen by" : "Not seen by"), pid_detectors[index], description) ;
data/unhide-20130526/unhide_rb.c:460:13:  [4] (buffer) strcat:
  Does not check for buffer overflows when concatenating to destination
  [MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
  snprintf (warning: strncat is easily misused).
            strcat(message, scratch) ;
data/unhide-20130526/unhide_rb.c:466:13:  [4] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused).
            strcpy(messages_pids[my_pid], message) ;
data/unhide-20130526/unhide-linux.c:507:11:  [3] (buffer) getopt_long:
  Some older implementations do not protect against internal buffer overflows
  (CWE-120, CWE-20). Check implementation on installation, or limit the size
  of all string inputs.
      c = getopt_long (argc, argv, "dformhvV",
data/unhide-20130526/unhide-tcp-simple-check.c:357:11:  [3] (buffer) getopt_long:
  Some older implementations do not protect against internal buffer overflows
  (CWE-120, CWE-20). Check implementation on installation, or limit the size
  of all string inputs.
      c = getopt_long (argc, argv, "Vvhflosn",
data/unhide-20130526/unhide-tcp.c:411:11:  [3] (buffer) getopt_long:
  Some older implementations do not protect against internal buffer overflows
  (CWE-120, CWE-20). Check implementation on installation, or limit the size
  of all string inputs.
      c = getopt_long (argc, argv, "Vvhflosn",
data/unhide-20130526/unhide-linux-bruteforce.c:101:19:  [2] (race) vfork:
  On some old systems, vfork() permits race conditions, and it's very
  difficult to use correctly (CWE-362). Use fork() instead.
      if ((vpid = vfork()) == 0) 
data/unhide-20130526/unhide-linux-bruteforce.c:122:22:  [2] (race) vfork:
  On some old systems, vfork() permits race conditions, and it's very
  difficult to use correctly (CWE-362). Use fork() instead.
         if ((vpid = vfork()) == 0) 
data/unhide-20130526/unhide-linux-compound.c:63:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char directory[100], *pathpt;
data/unhide-20130526/unhide-linux-compound.c:66:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char curdir[PATH_MAX] ;
data/unhide-20130526/unhide-linux-compound.c:78:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(directory,"/proc/");
data/unhide-20130526/unhide-linux-compound.c:125:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(&directory[6],"%d",syspids);
data/unhide-20130526/unhide-linux-compound.c:198:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char command[50];
data/unhide-20130526/unhide-linux-compound.c:199:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char read_line[1024];
data/unhide-20130526/unhide-linux-compound.c:200:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char lwp[7];
data/unhide-20130526/unhide-linux-compound.c:202:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char directory[100];
data/unhide-20130526/unhide-linux-compound.c:205:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char curdir[PATH_MAX], *pathpt ;
data/unhide-20130526/unhide-linux-compound.c:225:4:  [2] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused). Risk is low because the source is a constant string.
   strcpy(directory,"/proc/");
data/unhide-20130526/unhide-linux-compound.c:250:17:  [2] (integer) atol:
  Unless checked, the resulting number can exceed the expected range
  (CWE-190). If source untrusted, check both minimum and maximum, even if the
  input had no minus sign (large numbers can roll over into negative number;
  consider saving to an unsigned value if that is intended).
      syspids = atol(lwp);
data/unhide-20130526/unhide-linux-procfs.c:58:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char directory[100] ;
data/unhide-20130526/unhide-linux-procfs.c:62:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(directory,"/proc/");
data/unhide-20130526/unhide-linux-procfs.c:71:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(&directory[6],"%d",procpids);
data/unhide-20130526/unhide-linux-procfs.c:102:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char curdir[PATH_MAX], *pathpt ;
data/unhide-20130526/unhide-linux-procfs.c:103:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char directory[100] ;
data/unhide-20130526/unhide-linux-procfs.c:116:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(directory,"/proc/");
data/unhide-20130526/unhide-linux-procfs.c:126:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(&directory[6],"%d",procpids);
data/unhide-20130526/unhide-linux-procfs.c:138:10:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
         char  line[128] ;
data/unhide-20130526/unhide-linux-procfs.c:141:10:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
         char  new_directory[100];
data/unhide-20130526/unhide-linux-procfs.c:148:19:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
         fich_tmp=fopen("status", "r") ;
data/unhide-20130526/unhide-linux-procfs.c:240:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char directory[100] ;
data/unhide-20130526/unhide-linux-procfs.c:246:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(directory,"/proc/");
data/unhide-20130526/unhide-linux-procfs.c:256:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(&directory[6],"%d",procpids);
data/unhide-20130526/unhide-linux-procfs.c:267:10:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
         char  line[128] ;
data/unhide-20130526/unhide-linux-procfs.c:270:10:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
         char  new_directory[100] ;
data/unhide-20130526/unhide-linux-procfs.c:279:19:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
         fich_tmp=fopen(line, "r") ;
data/unhide-20130526/unhide-linux-procfs.c:367:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char task[100] ;
data/unhide-20130526/unhide-linux-procfs.c:378:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(task, "/proc/") ;
data/unhide-20130526/unhide-linux-procfs.c:419:24:  [2] (integer) atoi:
  Unless checked, the resulting number can exceed the expected range
  (CWE-190). If source untrusted, check both minimum and maximum, even if the
  input had no minus sign (large numbers can roll over into negative number;
  consider saving to an unsigned value if that is intended).
            procpids = atoi(tmp_d_name) ;
data/unhide-20130526/unhide-linux-procfs.c:423:25:  [2] (integer) atoi:
  Unless checked, the resulting number can exceed the expected range
  (CWE-190). If source untrusted, check both minimum and maximum, even if the
  input had no minus sign (large numbers can roll over into negative number;
  consider saving to an unsigned value if that is intended).
            printbadpid(atoi(tmp_d_name));
data/unhide-20130526/unhide-linux-procfs.c:427:24:  [2] (integer) atoi:
  Unless checked, the resulting number can exceed the expected range
  (CWE-190). If source untrusted, check both minimum and maximum, even if the
  input had no minus sign (large numbers can roll over into negative number;
  consider saving to an unsigned value if that is intended).
            procpids = atoi(tmp_d_name) ;
data/unhide-20130526/unhide-linux-procfs.c:431:25:  [2] (integer) atoi:
  Unless checked, the resulting number can exceed the expected range
  (CWE-190). If source untrusted, check both minimum and maximum, even if the
  input had no minus sign (large numbers can roll over into negative number;
  consider saving to an unsigned value if that is intended).
            printbadpid(atoi(tmp_d_name));
data/unhide-20130526/unhide-linux-syscall.c:463:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buffer[500];
data/unhide-20130526/unhide-linux-syscall.c:544:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buffer[500];
data/unhide-20130526/unhide-linux-syscall.c:624:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buffer[500];
data/unhide-20130526/unhide-linux-syscall.c:671:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char big_buffer[32768*6+1] ;
data/unhide-20130526/unhide-linux.c:81:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char used_options[1000];
data/unhide-20130526/unhide-linux.c:84:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char scratch[1000];
data/unhide-20130526/unhide-linux.c:97:14:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
   FILE* fd= fopen(path,"r");
data/unhide-20130526/unhide-linux.c:124:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char pids[30];
data/unhide-20130526/unhide-linux.c:126:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char compare[100];
data/unhide-20130526/unhide-linux.c:127:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char command[60];
data/unhide-20130526/unhide-linux.c:135:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(compare,"%i\n",tmppid);
data/unhide-20130526/unhide-linux.c:277:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char cmd[100] ;
data/unhide-20130526/unhide-linux.c:280:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char cmdcont[1000], fmtstart[128];
data/unhide-20130526/unhide-linux.c:284:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(fmtstart,"Found HIDDEN PID: %i", tmppid) ;
data/unhide-20130526/unhide-linux.c:287:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(cmd,"/proc/%i/cmdline",tmppid);
data/unhide-20130526/unhide-linux.c:294:15:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
      cmdfile=fopen (cmd, "r") ;
data/unhide-20130526/unhide-linux.c:313:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(cmd,"/proc/%i/exe",tmppid);
data/unhide-20130526/unhide-linux.c:339:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(cmd,"/proc/%i/comm",tmppid);
data/unhide-20130526/unhide-linux.c:343:18:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
         cmdfile=fopen (cmd, "r") ;
data/unhide-20130526/unhide-linux.c:382:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(cmd,"/proc/%i/environ",tmppid);
data/unhide-20130526/unhide-linux.c:386:10:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
         sprintf(cmd,"cat /proc/%i/environ | tr \"\\0\" \"\\n\" | grep -w 'USER'",tmppid) ;
data/unhide-20130526/unhide-linux.c:405:10:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
         sprintf(cmd,"cat /proc/%i/environ | tr \"\\0\" \"\\n\" | grep -w 'PWD'",tmppid) ;
data/unhide-20130526/unhide-linux.h:112:8:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
extern char used_options[1000];
data/unhide-20130526/unhide-linux.h:119:8:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
extern char scratch[1000];
data/unhide-20130526/unhide-output.c:39:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buf[BUFSIZ];
data/unhide-20130526/unhide-output.c:54:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buf[BUFSIZ];
data/unhide-20130526/unhide-output.c:82:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buf[BUFSIZ];
data/unhide-20130526/unhide-output.c:115:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buf[BUFSIZ];
data/unhide-20130526/unhide-output.c:141:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char filename[PATH_MAX] ;
data/unhide-20130526/unhide-output.c:144:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char cad[80];
data/unhide-20130526/unhide-output.c:155:9:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
   fh = fopen(filename, "w");
data/unhide-20130526/unhide-output.c:182:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char cad[80];
data/unhide-20130526/unhide-posix.c:68:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char scratch[1000];
data/unhide-20130526/unhide-posix.c:77:2:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
	char pids[30];
data/unhide-20130526/unhide-posix.c:78:2:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
	char compare[100];
data/unhide-20130526/unhide-posix.c:89:3:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
		sprintf(compare,"%i\n",tmppid);
data/unhide-20130526/unhide-posix.c:101:3:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
		char cmd[100] ;
data/unhide-20130526/unhide-posix.c:107:3:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
		sprintf(cmd,"/proc/%i/cmdline",tmppid);
data/unhide-20130526/unhide-posix.c:114:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
			char cmdcont[1000];
data/unhide-20130526/unhide-posix.c:116:12:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
			cmdfile=fopen (cmd, "r") ;
data/unhide-20130526/unhide-posix.c:142:3:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
		char directory[100] ;
data/unhide-20130526/unhide-posix.c:145:3:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
		sprintf(directory,"/proc/%d",procpids);
data/unhide-20130526/unhide-tcp-fast.c:45:8:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
static char netstat_ports[65536];
data/unhide-20130526/unhide-tcp-fast.c:46:8:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
static char hidden_ports[65536];
data/unhide-20130526/unhide-tcp-fast.c:47:8:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
static char check_ports[65536];
data/unhide-20130526/unhide-tcp-fast.c:201:7:  [2] (buffer) memcpy:
  Does not check for buffer overflows when copying to destination (CWE-120).
  Make sure destination can always hold the source data.
      memcpy(check_ports, hidden_ports, sizeof(hidden_ports));
data/unhide-20130526/unhide-tcp-simple-check.c:50:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char checker[10] = "ss" ;
data/unhide-20130526/unhide-tcp-simple-check.c:53:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char scratch[1000];
data/unhide-20130526/unhide-tcp-simple-check.c:56:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char used_options[1000] = "";
data/unhide-20130526/unhide-tcp-simple-check.c:100:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buffer[1000];
data/unhide-20130526/unhide-tcp-simple-check.c:160:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char ports[30];
data/unhide-20130526/unhide-tcp-simple-check.c:161:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char compare[100];
data/unhide-20130526/unhide-tcp-simple-check.c:167:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(compare,"%i\n",port);
data/unhide-20130526/unhide-tcp-simple-check.c:192:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char tcpcommand[512] ;
data/unhide-20130526/unhide-tcp-simple-check.c:262:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char udpcommand[512] ;
data/unhide-20130526/unhide-tcp.c:54:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char checker[10] = "ss" ;
data/unhide-20130526/unhide-tcp.c:57:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char scratch[1000];
data/unhide-20130526/unhide-tcp.c:60:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char used_options[1000] = "";
data/unhide-20130526/unhide-tcp.c:117:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char buffer[1000];
data/unhide-20130526/unhide-tcp.c:185:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char ports[30];
data/unhide-20130526/unhide-tcp.c:186:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char compare[100];
data/unhide-20130526/unhide-tcp.c:192:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(compare,"%i\n",port);
data/unhide-20130526/unhide-tcp.c:211:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char tcpcommand[512] ;
data/unhide-20130526/unhide-tcp.c:304:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char udpcommand[512] ;
data/unhide-20130526/unhide_rb.c:56:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char scratch[1000] ;
data/unhide-20130526/unhide_rb.c:57:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char cmdcont[1000] ;
data/unhide-20130526/unhide_rb.c:61:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char *proc_tasks[65536];
data/unhide-20130526/unhide_rb.c:62:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char *ps_pids[65536];
data/unhide-20130526/unhide_rb.c:63:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char *messages_pids[65536];
data/unhide-20130526/unhide_rb.c:64:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char message[1000] ;
data/unhide-20130526/unhide_rb.c:65:1:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
char description[1000] ;
data/unhide-20130526/unhide_rb.c:97:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char mypath[512] = "/proc/" ;
data/unhide-20130526/unhide_rb.c:98:4:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
   sprintf(mypath, "/proc/") ;
data/unhide-20130526/unhide_rb.c:122:10:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
         char  line[128] ;
data/unhide-20130526/unhide_rb.c:127:31:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
         if(NULL != (fich_tmp=fopen(mypath, "r")))
data/unhide-20130526/unhide_rb.c:163:16:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
               char myexe[512] ;
data/unhide-20130526/unhide_rb.c:193:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char myline[1000] ;
data/unhide-20130526/unhide_rb.c:258:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char mypath[50] ;
data/unhide-20130526/unhide_rb.c:261:4:  [2] (buffer) char:
  Statically-sized arrays can be improperly restricted, leading to potential
  overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
  functions that limit length, or ensure that the size is larger than the
  maximum possible length.
   char proc_exe[512] ;
data/unhide-20130526/unhide_rb.c:273:17:  [2] (misc) fopen:
  Check when opening files - can an attacker redirect it (via symlinks),
  force the opening of special file type (e.g., device files), move things
  around to create a race condition, control its ancestors, or change its
  contents? (CWE-362).
      FILE* fd= fopen(path,"r");
data/unhide-20130526/unhide_rb.c:304:7:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
      sprintf(mypath,"/proc/%d",my_pid);
data/unhide-20130526/unhide_rb.c:309:10:  [2] (buffer) strcat:
  Does not check for buffer overflows when concatenating to destination
  [MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
  snprintf (warning: strncat is easily misused). Risk is low because the
  source is a constant string.
         strcat(mypath,"/exe") ;
data/unhide-20130526/unhide_rb.c:319:13:  [2] (buffer) strcpy:
  Does not check for buffer overflows when copying to destination [MS-banned]
  (CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
  easily misused). Risk is low because the source is a constant string.
            strcpy(proc_exe,"unknown exe") ;
data/unhide-20130526/unhide_rb.c:431:10:  [2] (buffer) sprintf:
  Does not check for buffer overflows (CWE-120). Use sprintf_s, snprintf, or
  vsnprintf. Risk is low because the source has a constant maximum length.
         sprintf(message, "Suspicious PID %5d:", my_pid) ;
data/unhide-20130526/unhide-linux-compound.c:232:17:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      read_line[strlen(read_line)-1] = 0;
data/unhide-20130526/unhide-linux-syscall.c:494:20:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
            buffer[strlen(buffer)-1] = 0;  // get rid of \n
data/unhide-20130526/unhide-linux-syscall.c:575:20:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
            buffer[strlen(buffer)-1] = 0;  // get rid of \n
data/unhide-20130526/unhide-linux-syscall.c:709:27:  [1] (buffer) read:
  Check buffer boundaries if used in a loop including recursive loops
  (CWE-120, CWE-20).
      while ((read_size = read(fd, buf_pt, avail))) 
data/unhide-20130526/unhide-linux.c:351:28:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
               if (cmdcont[strlen(cmdcont)-1] == '\n')
data/unhide-20130526/unhide-linux.c:353:27:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
                  cmdcont[strlen(cmdcont)-1] = 0 ;  // get rid of newline
data/unhide-20130526/unhide-linux.c:396:21:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
            cmdcont[strlen(cmdcont)-1] = 0 ;  // get rid of newline
data/unhide-20130526/unhide-linux.c:415:21:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
            cmdcont[strlen(cmdcont)-1] = 0 ;  // get rid of newline
data/unhide-20130526/unhide-linux.c:565:4:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
   strncpy(used_options, "Used options: ", 1000);
data/unhide-20130526/unhide-linux.c:567:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "verbose ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:567:48:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "verbose ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:569:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "brutesimplecheck ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:569:57:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "brutesimplecheck ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:571:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "morecheck ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:571:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "morecheck ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:573:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "RTsys ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:573:46:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "RTsys ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:575:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "logtofile ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-linux.c:575:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "logtofile ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-output.c:59:7:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant character.
      strncpy(buf, "\t", BUFSIZ);
data/unhide-20130526/unhide-output.c:60:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings.
      strncat(buf, fmt, BUFSIZ-strlen(buf));
data/unhide-20130526/unhide-output.c:60:32:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(buf, fmt, BUFSIZ-strlen(buf));
data/unhide-20130526/unhide-output.c:64:7:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120).
      strncpy(buf, fmt, BUFSIZ);
data/unhide-20130526/unhide-output.c:66:4:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant character.
   strncat(buf, "\n", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:66:32:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
   strncat(buf, "\n", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:91:4:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
   strncpy(buf, "Warning : ", BUFSIZ);
data/unhide-20130526/unhide-output.c:92:4:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings.
   strncat(buf, fmt, BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:92:31:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
   strncat(buf, fmt, BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:95:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(buf, " [", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:95:35:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(buf, " [", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:96:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings.
      strncat(buf, strerror(e), BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:96:42:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(buf, strerror(e), BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:97:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant character.
      strncat(buf, "]", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:97:34:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(buf, "]", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:99:4:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant character.
   strncat(buf, "\n", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:99:32:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
   strncat(buf, "\n", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:118:4:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
   strncpy(buf, "Error : ", BUFSIZ);
data/unhide-20130526/unhide-output.c:119:4:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings.
   strncat(buf, fmt, BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:119:31:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
   strncat(buf, fmt, BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:122:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(buf, " [", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:122:35:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(buf, " [", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:123:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings.
      strncat(buf, strerror(e), BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:123:42:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(buf, strerror(e), BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:124:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant character.
      strncat(buf, "]", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:124:34:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(buf, "]", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:126:4:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant character.
   strncat(buf, "\n", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-output.c:126:32:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
   strncat(buf, "\n", BUFSIZ-1-strlen(buf));
data/unhide-20130526/unhide-posix.c:234:2:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
	strncpy(scratch,"Unhide-posix 20130526\n", 1000) ;
data/unhide-20130526/unhide-posix.c:235:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "Copyright © 2013 Yago Jesus & Patrick Gouin\n", 1000);
data/unhide-20130526/unhide-posix.c:236:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "License GPLv3+ : GNU GPL version 3 or later\n", 1000);
data/unhide-20130526/unhide-posix.c:237:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "http://www.unhide-forensics.info\n\n", 1000);
data/unhide-20130526/unhide-posix.c:238:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "NOTE : This is legacy version of unhide, it is intended\n\
data/unhide-20130526/unhide-tcp-simple-check.c:218:19:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120).
                  strncpy(tcpcommand, tcpcommand1, 512) ;
data/unhide-20130526/unhide-tcp-simple-check.c:238:19:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120).
                  strncpy(tcpcommand, tcpcommand1, 512) ;
data/unhide-20130526/unhide-tcp-simple-check.c:288:19:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120).
                  strncpy(udpcommand, udpcommand1, 512) ;
data/unhide-20130526/unhide-tcp-simple-check.c:414:4:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
   strncpy(used_options, "Used options: ", 1000);
data/unhide-20130526/unhide-tcp-simple-check.c:416:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "verbose ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:416:48:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "verbose ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:418:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_lsof ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:418:49:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_lsof ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:420:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_fuser ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:420:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_fuser ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:422:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_netscape ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:422:53:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_netscape ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:424:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_quick ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:424:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_quick ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:426:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "logtofile ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:426:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "logtofile ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp-simple-check.c:455:7:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
      strncpy(checker, "ss", 10);
data/unhide-20130526/unhide-tcp-simple-check.c:459:7:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
      strncpy(checker, "netstat", 10);
data/unhide-20130526/unhide-tcp.c:236:19:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120).
                  strncpy(tcpcommand, tcpcommand1, 512) ;
data/unhide-20130526/unhide-tcp.c:265:19:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120).
                  strncpy(tcpcommand, tcpcommand1, 512) ;
data/unhide-20130526/unhide-tcp.c:329:19:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120).
                  strncpy(udpcommand, udpcommand1, 512) ;
data/unhide-20130526/unhide-tcp.c:468:4:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
   strncpy(used_options, "Used options: ", 1000);
data/unhide-20130526/unhide-tcp.c:470:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "verbose ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:470:48:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "verbose ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:472:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_lsof ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:472:49:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_lsof ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:474:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_fuser ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:474:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_fuser ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:476:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_netscape ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:476:53:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_netscape ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:478:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "use_quick ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:478:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "use_quick ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:480:7:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
      strncat(used_options, "logtofile ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:480:50:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
      strncat(used_options, "logtofile ", 1000-1-strlen(used_options));
data/unhide-20130526/unhide-tcp.c:510:7:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
      strncpy(checker, "ss", 10);
data/unhide-20130526/unhide-tcp.c:514:7:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
      strncpy(checker, "netstat", 10);
data/unhide-20130526/unhide_rb.c:225:37:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
                  my_end = myline + strlen(myline) -1 ;
data/unhide-20130526/unhide_rb.c:233:43:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
                  ps_pids[mypid] = malloc(strlen(myline+5)+1) ;
data/unhide-20130526/unhide_rb.c:465:44:  [1] (buffer) strlen:
  Does not handle strings that are not \0-terminated; if given one it may
  perform an over-read (it could cause a crash if unprotected) (CWE-126).
            messages_pids[my_pid] = malloc(strlen(message)+1) ;
data/unhide-20130526/unhide_rb.c:486:2:  [1] (buffer) strncpy:
  Easily used incorrectly; doesn't always \0-terminate or check for invalid
  pointers [MS-banned] (CWE-120). Risk is low because the source is a
  constant string.
	strncpy(scratch,"Unhide_rb 20130526\n", 1000) ;
data/unhide-20130526/unhide_rb.c:488:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "Copyright © 2013 Yago Jesus & Patrick Gouin\n", 1000);
data/unhide-20130526/unhide_rb.c:489:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "License GPLv3+ : GNU GPL version 3 or later\n", 1000);
data/unhide-20130526/unhide_rb.c:490:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "http://www.unhide-forensics.info\n\n", 1000);
data/unhide-20130526/unhide_rb.c:491:2:  [1] (buffer) strncat:
  Easily used incorrectly (e.g., incorrectly computing the correct maximum
  size to add) [MS-banned] (CWE-120). Consider strcat_s, strlcat, snprintf,
  or automatically resizing strings. Risk is low because the source is a
  constant string.
	strncat(scratch, "NOTE : This version of unhide_rb is for systems using Linux >= 2.6 \n\n", 1000);

ANALYSIS SUMMARY:

Hits = 272
Lines analyzed = 5158 in approximately 0.14 seconds (37005 lines/second)
Physical Source Lines of Code (SLOC) = 3577
Hits@level = [0]  93 [1]  96 [2] 119 [3]   3 [4]  51 [5]   3
Hits@level+ = [0+] 365 [1+] 272 [2+] 176 [3+]  57 [4+]  54 [5+]   3
Hits/KSLOC@level+ = [0+] 102.041 [1+] 76.0414 [2+] 49.2032 [3+] 15.9351 [4+] 15.0964 [5+] 0.838692
Dot directories skipped = 1 (--followdotdir overrides)
Minimum risk level = 1
Not every hit is necessarily a security vulnerability.
There may be other security vulnerabilities; review your code!
See 'Secure Programming HOWTO'
(https://dwheeler.com/secure-programs) for more information.