Changeset 425


Ignore:
Timestamp:
Feb 20, 2013, 7:30:02 PM (7 years ago)
Author:
katerina
Message:

Fix for tickets #329, #330, #331, #332

Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/Makefile.in

    r415 r425  
    356356CLEANFILES = encode config_xor.h depend-gen sh_ks.h sh_ks_xor.h kern_head \
    357357        internal.h sh_MK.h trustfile sstrip samhain mkhdr encode cutest \
    358         yule samhain_setpwd samhain_stealth samhainrc yulectl samhain_hide.ko
     358        yule samhain_setpwd samhain_stealth samhainrc yulectl \
     359        samhain_hide.ko samhain_kmem.ko
    359360
    360361clean:
     
    932933        echo " A file integrity checker"  >> debian/control; \
    933934        echo "running debuild -us -uc"; \
    934         debuild -us -uc -b; \
     935        debuild --preserve-envvar=PASSWORD -us -uc -b; \
    935936        DEBFILE=`find ../ -follow -maxdepth 1 -cnewer ./debian/control 2>/dev/null | grep '@install_name@_$(VERSION)' | grep '\.deb'`; \
    936937        if test x"$$DEBFILE" = x; then \
  • trunk/configure.ac

    r424 r425  
    1212dnl start
    1313dnl
    14 AM_INIT_AUTOMAKE(samhain, 3.0.10)
     14AM_INIT_AUTOMAKE(samhain, 3.0.11)
    1515AC_DEFINE([SAMHAIN], 1, [Application is samhain])
    1616AC_CANONICAL_HOST
  • trunk/docs/Changelog

    r424 r425  
     13.0.11:
     2        * Add better logrotate handling for the GrowingLogs policy (search
     3          rotated log and verify it, don't report if this succeeds)
     4        * Add ability to create debian packages with preset password (use
     5          env var PASSWORD)
     6        * Add option KernelCheckProc (bool) to suppress kernel /proc test
     7        * Add option IgnoreModified to cover transient files that
     8          not only get added/deleted but also modified
     9
    1103.0.10:
    211        * Revert to previous logic in samhain.c because it will block
  • trunk/include/sh_ignore.h

    r170 r425  
    44int sh_ignore_add_del (const char * addpath);
    55int sh_ignore_add_new (const char * addpath);
     6int sh_ignore_add_mod (const char * addpath);
    67
    78int sh_ignore_chk_del (const char * chkpath);
    89int sh_ignore_chk_new (const char * chkpath);
     10int sh_ignore_chk_mod (const char * chkpath);
    911
    1012int sh_ignore_clean (void);
  • trunk/include/sh_kern.h

    r223 r425  
    1717int sh_kern_set_idt      (const char * c);
    1818int sh_kern_set_pci      (const char * c);
     19int sh_kern_set_proc     (const char * c);
    1920int sh_kern_set_sct_addr (const char * c);
    2021int sh_kern_set_sc_addr  (const char * c);
  • trunk/include/sh_unix.h

    r411 r425  
    311311/* int sh_unix_is_secure_dir (ShErrLevel level, char * tmp); */
    312312
     313/* check whether there's a rotated log with the correct inode and checksum
     314 */
     315int sh_check_rotated_log (const char * path, 
     316                          UINT64 old_size, UINT64 old_inode, const char * old_hash);
     317
    313318/* obtain file info
    314319 */
  • trunk/rules.deb-light.in

    r209 r425  
    2727        echo '#!/bin/sh' > ./sstrip
    2828        echo 'echo "*** SSTRIP DISABLED ***"' >> ./sstrip
     29        if ! test x$(PASSWORD) = x; then \
     30                if test -f samhain_setpwd; then \
     31                        ./samhain_setpwd samhain new $(PASSWORD); \
     32                        rm samhain; \
     33                        mv samhain.new samhain; \
     34                fi; \
     35        fi
    2936        touch build-stamp
    3037
  • trunk/rules.deb.in

    r209 r425  
    2727        echo '#!/bin/sh' > ./sstrip
    2828        echo 'echo "*** SSTRIP DISABLED ***"' >> ./sstrip
     29        if ! test x$(PASSWORD) = x; then \
     30                if test -f samhain_setpwd; then \
     31                        ./samhain_setpwd samhain new $(PASSWORD); \
     32                        rm samhain; \
     33                        mv samhain.new samhain; \
     34                fi; \
     35        fi
    2936        touch build-stamp
    3037
  • trunk/src/sh_fInotify.c

    r405 r425  
    525525{
    526526  int    reported;
    527   int ret = sh_files_search_file(path, &class, &check_mask, &reported);
    528 
    529   if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
    530     {
    531       ; /* do nothing, watch was for directory monitored as file only */
    532     }
    533   else
    534     {
    535       sh_files_filecheck (class, check_mask, filename,
    536                           (event->len > 0) ? event->name : NULL,
    537                           &reported, 0);
     527  int ret;
     528
     529
     530  if (S_FALSE == sh_ignore_chk_mod(path))
     531    {
     532      ret  = sh_files_search_file(path, &class, &check_mask, &reported);
     533
     534      if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
     535        {
     536          ; /* do nothing, watch was for directory monitored as file only */
     537        }
     538      else
     539        {
     540          sh_files_filecheck (class, check_mask, filename,
     541                              (event->len > 0) ? event->name : NULL,
     542                              &reported, 0);
     543        }
    538544    }
    539545  return 0;
  • trunk/src/sh_files.c

    r405 r425  
    24502450  char          * tmpname;
    24512451  const char    * fileName;
     2452#if !defined(O_NOATIME)
    24522453  struct utimbuf  utime_buf;
     2454#endif
    24532455  static unsigned int state = 1;
    24542456  char            sc;
     
    26042606  /* reset the access time
    26052607   */
     2608#if !defined(O_NOATIME)
    26062609  if (class == SH_LEVEL_NOIGNORE && (theFile->check_mask & MODI_ATM) != 0)
    26072610    {
    26082611      utime_buf.actime   = (time_t) theFile->atime;
    26092612      utime_buf.modtime  = (time_t) theFile->mtime;
    2610 #if !defined(O_NOATIME)
     2613
    26112614      retry_aud_utime (FIL__, __LINE__, fullpath, &utime_buf);
    2612 #endif
    2613     }
     2615    }
     2616#endif
    26142617 
    26152618#if defined(HOST_IS_DARWIN)
  • trunk/src/sh_hash.c

    r405 r425  
    30353035    }
    30363036
     3037  /* ---------  Skip if we don't want to report changes. ------------
     3038   */
     3039 
     3040  if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
     3041    {
     3042      goto unlock_and_return;
     3043    }
     3044
    30373045  p->modi_mask = theFile->check_mask;
    30383046
     
    30573065      else
    30583066        {
    3059           if (0 != strncmp (&fileHash[KEY_LEN + 1],
    3060                             p->theFile.checksum, KEY_LEN))
     3067          if (0 != strncmp (&fileHash[KEY_LEN + 1], p->theFile.checksum, KEY_LEN))
    30613068            {
    3062               modi_mask |= MODI_CHK;
    3063               change_code[0] = 'C';
    3064               TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
     3069              if (S_FALSE == sh_check_rotated_log (theFile->fullpath, (UINT64) p->theFile.size,
     3070                                                   (UINT64) p->theFile.ino, p->theFile.checksum))
     3071                {
     3072                  modi_mask |= MODI_CHK;
     3073                  change_code[0] = 'C';
     3074                  TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
     3075                }
     3076              else
     3077                {
     3078                  /* logfile has been rotated */
     3079                  p->theFile.size  = theFile->size;
     3080                  p->theFile.ino   = theFile->ino;
     3081                  sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
     3082                }
    30653083            }
    30663084          else
  • trunk/src/sh_ignore.c

    r333 r425  
    5353static struct sh_ignore_list * sh_del_ign = NULL;
    5454static struct sh_ignore_list * sh_new_ign = NULL;
     55static struct sh_ignore_list * sh_mod_ign = NULL;
    5556
    5657static struct sh_ignore_list * sh_ignore_add_int(struct sh_ignore_list * list,
     
    118119}
    119120
     121int sh_ignore_add_mod (const char * addpath)
     122{
     123  if ((addpath == NULL) || (addpath[0] != '/'))
     124    {
     125      return -1;
     126    }
     127  sh_mod_ign = sh_ignore_add_int (sh_mod_ign, addpath);
     128  return 0;
     129}
     130
    120131static int sh_ignore_chk_int (struct sh_ignore_list * list,
    121132                              const char * chkpath)
     
    159170}
    160171
     172int sh_ignore_chk_mod (const char * chkpath)
     173{
     174  return (sh_ignore_chk_int(sh_mod_ign, chkpath));
     175}
     176
    161177int sh_ignore_clean (void)
    162178{
     
    191207    }
    192208
     209  new = sh_mod_ign;
     210
     211  while (new)
     212    {
     213      sh_mod_ign = new->next;
     214#ifdef HAVE_REGEX_H
     215      regfree (&(new->preg));
     216#else
     217      SH_FREE(new->path);
     218#endif
     219      SH_FREE(new);
     220      new        = sh_mod_ign;
     221    }
     222
    193223  return 0;
    194224}
     
    205235  CuAssertTrue(tc, NULL == sh_del_ign);
    206236  CuAssertTrue(tc, NULL == sh_new_ign);
     237  CuAssertTrue(tc, NULL == sh_mod_ign);
    207238 
    208239  ret = sh_ignore_add_del ("/var/log/foo/.*");
    209240  CuAssertTrue(tc, 0 == ret);
     241
    210242  CuAssertPtrNotNull(tc, sh_del_ign);
     243  CuAssertTrue(tc, NULL == sh_new_ign);
     244  CuAssertTrue(tc, NULL == sh_mod_ign);
    211245
    212246  ret = sh_ignore_chk_del ("/var/log/foo/test");
    213247  CuAssertTrue(tc, S_TRUE == ret);
    214   CuAssertTrue(tc, NULL == sh_new_ign);
    215248 
    216249  ret = sh_ignore_chk_del ("/var/log/footest");
     
    223256  CuAssertTrue(tc, NULL == sh_del_ign);
    224257  CuAssertTrue(tc, NULL == sh_new_ign);
     258  CuAssertTrue(tc, NULL == sh_mod_ign);
    225259 
    226260  ret = sh_ignore_add_new ("/var/log/foo/.*");
    227261  CuAssertTrue(tc, 0 == ret);
     262
    228263  CuAssertPtrNotNull(tc, sh_new_ign);
    229264  CuAssertTrue(tc, NULL == sh_del_ign);
     265  CuAssertTrue(tc, NULL == sh_mod_ign);
    230266
    231267  ret = sh_ignore_chk_new ("/var/log/foo/test");
     
    241277  CuAssertTrue(tc, NULL == sh_new_ign);
    242278  CuAssertTrue(tc, NULL == sh_del_ign);
     279  CuAssertTrue(tc, NULL == sh_mod_ign);
     280
     281  ret = sh_ignore_add_mod ("/var/log/foo/.*");
     282  CuAssertTrue(tc, 0 == ret);
     283
     284  CuAssertPtrNotNull(tc, sh_mod_ign);
     285  CuAssertTrue(tc, NULL == sh_del_ign);
     286  CuAssertTrue(tc, NULL == sh_new_ign);
     287
     288  ret = sh_ignore_chk_mod ("/var/log/foo/test");
     289  CuAssertTrue(tc, S_TRUE == ret);
     290 
     291  ret = sh_ignore_chk_mod ("/var/log/footest");
     292  CuAssertTrue(tc, S_FALSE == ret);
     293
     294  ret = sh_ignore_chk_mod ("/my/var/log/footest");
     295  CuAssertTrue(tc, S_FALSE == ret);
     296
     297  sh_ignore_clean();
     298  CuAssertTrue(tc, NULL == sh_new_ign);
     299  CuAssertTrue(tc, NULL == sh_del_ign);
     300  CuAssertTrue(tc, NULL == sh_mod_ign);
    243301
    244302#else
  • trunk/src/sh_kern.c

    r362 r425  
    9090    N_("kernelcheckpci"),
    9191    sh_kern_set_pci
     92  },
     93  {
     94    N_("kernelcheckproc"),
     95    sh_kern_set_proc
    9296  },
    9397  {
     
    125129static int     ShKernIDT      = S_TRUE;
    126130static int     ShKernPCI      = S_TRUE;
     131static int     ShKernPROC     = S_TRUE;
    127132
    128133/* The address of system_call
     
    11041109#if SH_KERNEL_NUMBER < KERNEL_VERSION(2,6,21)
    11051110  struct inode_operations proc_root_inode;
    1106 
     1111#endif
     1112
     1113  if (ShKernPROC != S_TRUE)
     1114    return;
     1115
     1116/* 2.6.21 (((2) << 16) + ((6) << 8) + (21)) */
     1117#if SH_KERNEL_NUMBER < KERNEL_VERSION(2,6,21)
    11071118  memcpy (&proc_root_inode, &(kinfo->proc_root_inode), sizeof(struct inode_operations));
    11081119
     
    20172028}
    20182029
     2030int sh_kern_set_proc (const char * c)
     2031{
     2032  int i;
     2033  SL_ENTER(_("sh_kern_set_proc"));
     2034  i = sh_util_flagval(c, &ShKernPROC);
     2035  SL_RETURN(i, _("sh_kern_set_proc"));
     2036}
     2037
    20192038int sh_kern_set_sc_addr (const char * c)
    20202039{
  • trunk/src/sh_log_check.c

    r415 r425  
    577577 * Search rotated logfile
    578578 */
    579 #include <unistd.h>
    580 #include <libgen.h>
    581 #include <dirent.h>
    582 
    583 char * sh_rotated_log_search(const char * path, struct stat * buf)
    584 {
    585 
    586   size_t size;
    587   int    i;
    588   char * searchpath;
    589   struct stat sbuf;
    590   DIR  * dp;
    591   char * dname;
    592   char * bname;
    593 
    594   dname  = sh_util_dirname(path);
    595   bname  = sh_util_basename(path);
    596 
    597   size = strlen(dname) + strlen(bname) + 4;
    598   searchpath = SH_ALLOC(size);
    599 
    600   for (i = 0; i < 2; ++i)
    601     {
    602       snprintf(searchpath, size, "%s/%s.%1d", dname, bname, i);
    603       if (0 == stat(searchpath, &sbuf) && sbuf.st_ino == buf->st_ino)
    604         {
    605           SH_FREE(dname);
    606           SH_FREE(bname);
    607           return searchpath;
    608         }
    609     }
    610 
    611   SH_FREE(searchpath);
    612 
    613   if (NULL != (dp = opendir(dname)))
    614     {
    615       struct dirent * de;
    616 
    617       while (NULL != (de = readdir(dp)))
    618         {
    619           if (0 == strcmp(de->d_name, ".") || 0 == strcmp(de->d_name, ".."))
    620             continue;
    621 
    622           size = strlen(dname) + strlen(de->d_name) + 2;
    623           searchpath = SH_ALLOC(size);
    624           snprintf(searchpath, size, "%s/%s", dname, de->d_name);
    625 
    626           if (0 == stat(searchpath, &sbuf) && sbuf.st_ino == buf->st_ino)
    627             {
    628               SH_FREE(dname);
    629               SH_FREE(bname);
    630               closedir(dp);
    631               return searchpath;
    632             }
    633          
    634           SH_FREE(searchpath);
    635         }
    636       closedir(dp);
    637     }
    638 
    639   SH_FREE(dname);
    640   SH_FREE(bname);
    641 
    642   return NULL;
    643 }
     579extern char * sh_rotated_log_search(const char * path, struct stat * buf);
     580
    644581
    645582/* Open file, position at stored offset
  • trunk/src/sh_readconf.c

    r411 r425  
    965965  { N_("ignoremissing"), SH_SECTION_MISC,   SH_SECTION_NONE,
    966966    sh_ignore_add_del },
     967  { N_("ignoremodified"), SH_SECTION_MISC,   SH_SECTION_NONE,
     968    sh_ignore_add_mod },
    967969
    968970  { N_("skipchecksum"),  SH_SECTION_MISC,   SH_SECTION_NONE,
  • trunk/src/sh_tools.c

    r407 r425  
    20502050}
    20512051#endif
     2052
     2053/********************************************************
     2054 * Search rotated logfile
     2055 */
     2056#include <unistd.h>
     2057#include <libgen.h>
     2058#include <dirent.h>
     2059
     2060char * sh_rotated_log_search(const char * path, struct stat * buf)
     2061{
     2062
     2063  size_t size;
     2064  int    i;
     2065  char * searchpath;
     2066  struct stat sbuf;
     2067  DIR  * dp;
     2068  char * dname;
     2069  char * bname;
     2070
     2071  dname  = sh_util_dirname(path);
     2072  bname  = sh_util_basename(path);
     2073
     2074  size = strlen(dname) + strlen(bname) + 4;
     2075  searchpath = SH_ALLOC(size);
     2076
     2077  for (i = 0; i < 2; ++i)
     2078    {
     2079      snprintf(searchpath, size, "%s/%s.%1d", dname, bname, i);
     2080      if (0 == stat(searchpath, &sbuf) && sbuf.st_ino == buf->st_ino)
     2081        {
     2082          SH_FREE(dname);
     2083          SH_FREE(bname);
     2084          return searchpath;
     2085        }
     2086    }
     2087
     2088  SH_FREE(searchpath);
     2089
     2090  if (NULL != (dp = opendir(dname)))
     2091    {
     2092      struct dirent * de;
     2093
     2094      while (NULL != (de = readdir(dp)))
     2095        {
     2096          if (0 == strcmp(de->d_name, ".") || 0 == strcmp(de->d_name, ".."))
     2097            continue;
     2098
     2099          size = strlen(dname) + strlen(de->d_name) + 2;
     2100          searchpath = SH_ALLOC(size);
     2101          snprintf(searchpath, size, "%s/%s", dname, de->d_name);
     2102
     2103          if (0 == stat(searchpath, &sbuf) && sbuf.st_ino == buf->st_ino)
     2104            {
     2105              SH_FREE(dname);
     2106              SH_FREE(bname);
     2107              closedir(dp);
     2108              return searchpath;
     2109            }
     2110         
     2111          SH_FREE(searchpath);
     2112        }
     2113      closedir(dp);
     2114    }
     2115
     2116  SH_FREE(dname);
     2117  SH_FREE(bname);
     2118
     2119  return NULL;
     2120}
     2121
  • trunk/src/sh_unix.c

    r415 r425  
    34283428#include "sh_ignore.h"
    34293429
    3430 int sh_unix_checksum_size (char * filename, struct stat * fbuf,
     3430int sh_unix_checksum_size (char * filename, off_t size, int is_max_size,
    34313431                           char * fileHash, int alert_timeout, SL_TICKET fd)
    34323432{
     
    34423442    {
    34433443      /* lookup file in database */
    3444       status = sh_hash_get_it (filename, tmpFile, NULL);
    3445       if (status != 0) {
    3446         goto out;
     3444      if (is_max_size == S_TRUE) {
     3445        status = sh_hash_get_it (filename, tmpFile, NULL);
     3446        if ((status != 0) || (tmpFile->size > size)) {
     3447          goto out;
     3448        }
     3449      } else {
     3450        tmpFile->size = size;
    34473451      }
    34483452    }
    34493453  else
    34503454    {
    3451       tmpFile->size = fbuf->st_size;
    3452     }
    3453 
    3454   /* if last < current get checksum */
    3455   if (tmpFile->size < fbuf->st_size)
     3455      tmpFile->size = size;
     3456    }
     3457
     3458  /* if last <= current get checksum */
     3459  if (tmpFile->size <= size)
    34563460    {
    34573461      char hashbuf[KEYBUF_SIZE];
     
    34743478  SL_RETURN( -1, _("sh_unix_checksum_size"));
    34753479}
     3480
     3481/********************************************************
     3482 * Search rotated logfile
     3483 */
     3484extern char * sh_rotated_log_search(const char * path, struct stat * buf);
     3485
     3486int sh_check_rotated_log (const char * path, 
     3487                          UINT64 old_size, UINT64 old_inode, const char * old_hash)
     3488{
     3489  struct stat obuf;
     3490  UINT64 length_nolim = TIGER_NOLIM;
     3491  int retval = S_FALSE;
     3492
     3493  if (old_size != length_nolim)
     3494    {
     3495      char hashbuf[KEYBUF_SIZE];
     3496      char * rotated_file;
     3497
     3498      obuf.st_ino = old_inode;
     3499      rotated_file = sh_rotated_log_search(path, &obuf);
     3500
     3501      if (rotated_file && (0 != strcmp(path, rotated_file)))
     3502        {
     3503          SL_TICKET fd = sl_open_fastread (FIL__, __LINE__, rotated_file, SL_YESPRIV);
     3504          if (!SL_ISERROR(fd))
     3505            {
     3506              sh_unix_checksum_size (rotated_file, old_size, S_FALSE, hashbuf, 120 /* alert_timeout */, fd);
     3507             
     3508              sl_close(fd);
     3509             
     3510              if (strncmp (old_hash, hashbuf, KEY_LEN) == 0) {
     3511                retval = S_TRUE;
     3512              }
     3513            }
     3514          SH_FREE(rotated_file);
     3515        }
     3516    }
     3517  return retval;
     3518}
     3519
    34763520
    34773521int sh_unix_check_selinux = S_FALSE;
     
    39013945            {
    39023946              char hashbuf[KEYBUF_SIZE];
    3903               UINT64 length_nolim = TIGER_NOLIM;
     3947              UINT64 length_current = TIGER_NOLIM;
    39043948
    39053949              if (MODI_TXT_ENABLED(theFile->check_mask) && fbuf.st_size < (10 * SH_TXT_MAX))
     
    39103954              sl_strlcpy(fileHash,
    39113955                         sh_tiger_generic_hash (theFile->fullpath,
    3912                                                 rval_open, &length_nolim,
     3956                                                rval_open, &length_current,
    39133957                                                alert_timeout,
    39143958                                                hashbuf, sizeof(hashbuf)),
     
    39203964              if ((theFile->check_mask & MODI_SGROW) != 0)
    39213965                {
    3922                   fbuf.st_size = (off_t) length_nolim;
    39233966                  buf.st_size  = fbuf.st_size;
    39243967                  sl_rewind(rval_open);
    3925                   sh_unix_checksum_size (theFile->fullpath, &fbuf,
     3968                  sh_unix_checksum_size (theFile->fullpath, length_current, S_TRUE,
    39263969                                         &fileHash[KEY_LEN + 1],
    39273970                                         alert_timeout, rval_open);
     
    39563999            {
    39574000              char hashbuf[KEYBUF_SIZE];
    3958               UINT64 length_nolim = TIGER_NOLIM;
     4001              UINT64 length_current = TIGER_NOLIM;
    39594002
    39604003              if (MODI_TXT_ENABLED(theFile->check_mask) && fbuf.st_size < (10 * SH_TXT_MAX))
     
    39654008              sl_strlcpy(fileHash,
    39664009                         sh_tiger_generic_hash (theFile->fullpath, rval_open,
    3967                                                 &length_nolim,
     4010                                                &length_current,
    39684011                                                alert_timeout,
    39694012                                                hashbuf, sizeof(hashbuf)),
     
    39754018              if ((theFile->check_mask & MODI_SGROW) != 0)
    39764019                {
    3977                   fbuf.st_size = (off_t) length_nolim;
    39784020                  buf.st_size  = fbuf.st_size;
    39794021                  sl_rewind(rval_open);
    3980                   sh_unix_checksum_size (theFile->fullpath, &fbuf,
     4022                  sh_unix_checksum_size (theFile->fullpath, length_current, S_TRUE,
    39814023                                         &fileHash[KEY_LEN + 1],
    39824024                                         alert_timeout, rval_open);
Note: See TracChangeset for help on using the changeset viewer.