PHPIDS
Current file: | /home/lstrojny/Projekte/php-ids/trunk/lib/IDS/Filter/Storage.php
Legend: | executed not executed dead code

| Coverage
| Classes | Methods | Lines
Total |
| 100.00% | 1 / 1 |
| 100.00% | 7 / 7 |
| 84.96% | 113 / 133
IDS_Filter_Storage |
| 100.00% | 1 / 1 |
| 100.00% | 7 / 7 |
| 84.96% | 113 / 133
public function __construct(IDS_Init $init) |
| 100.00% | 1 / 1 |
| 86.36% | 19 / 22
public function setFilterSet($filterSet) |
| 100.00% | 1 / 1 |
| 100.00% | 4 / 4
public function getFilterSet() |
| 100.00% | 1 / 1 |
| 100.00% | 1 / 1
public function addFilter(IDS_Filter $filter) |
| 100.00% | 1 / 1 |
| 100.00% | 2 / 2
private function _isCached() |
| 100.00% | 1 / 1 |
| 100.00% | 7 / 7
public function getFilterFromXML() |
| 100.00% | 1 / 1 |
| 89.80% | 44 / 49
public function getFilterFromJson() |
| 100.00% | 1 / 1 |
| 75.00% | 36 / 48

           1                 : <?php
           2                 :
           3                 : /**
           4                 :  * PHPIDS
           5                 :  *
           6                 :  * Requirements: PHP5, SimpleXML
           7                 :  *
           8                 :  * Copyright (c) 2008 PHPIDS group (https://phpids.org)
           9                 :  *
          10                 :  * PHPIDS is free software; you can redistribute it and/or modify
          11                 :  * it under the terms of the GNU Lesser General Public License as published by
          12                 :  * the Free Software Foundation, version 3 of the License, or
          13                 :  * (at your option) any later version.
          14                 :  *
          15                 :  * PHPIDS is distributed in the hope that it will be useful,
          16                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
          17                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
          18                 :  * GNU Lesser General Public License for more details.
          19                 :  *
          20                 :  * You should have received a copy of the GNU Lesser General Public License
          21                 :  * along with PHPIDS. If not, see <http://www.gnu.org/licenses/>.
          22                 :  *
          23                 :  * PHP version 5.1.6+
          24                 :  *
          25                 :  * @category Security
          26                 :  * @package  PHPIDS
          27                 :  * @author   Mario Heiderich <mario.heiderich@gmail.com>
          28                 :  * @author   Christian Matthies <ch0012@gmail.com>
          29                 :  * @author   Lars Strojny <lars@strojny.net>
          30                 :  * @license  http://www.gnu.org/licenses/lgpl.html LGPL
          31                 :  * @link     http://php-ids.org/
          32                 :  */
          33                 :
          34                 : /**
          35                 :  * Filter Storage
          36                 :  *
          37                 :  * This class provides various default functions for gathering filter patterns
          38                 :  * to be used later on by the detection mechanism. You might extend this class
          39                 :  * to your requirements.
          40                 :  *
          41                 :  * @category  Security
          42                 :  * @package   PHPIDS
          43                 :  * @author    Christian Matthies <ch0012@gmail.com>
          44                 :  * @author    Mario Heiderich <mario.heiderich@gmail.com>
          45                 :  * @author    Lars Strojny <lars@strojny.net>
          46                 :  * @copyright 2007 The PHPIDS Group
          47                 :  * @license   http://www.gnu.org/licenses/lgpl.html LGPL
          48                 :  * @version   Release: $Id:Storage.php 517 2007-09-15 15:04:13Z mario $
          49                 :  * @link      http://php-ids.org/
          50                 :  */
          51                 : class IDS_Filter_Storage
          52                 : {
          53                 :
          54                 :     /**
          55                 :      * Filter source file
          56                 :      *
          57                 :      * @var string
          58                 :      */
          59                 :     protected $source = null;
          60                 :
          61                 :     /**
          62                 :      * Holds caching settings
          63                 :      *
          64                 :      * @var array
          65                 :      */
          66                 :     protected $cacheSettings = null;
          67                 :
          68                 :     /**
          69                 :      * Cache container
          70                 :      *
          71                 :      * @var object IDS_Caching wrapper
          72                 :      */
          73                 :     protected $cache = null;
          74                 :
          75                 :     /**
          76                 :      * Filter container
          77                 :      *
          78                 :      * @var array
          79                 :      */
          80                 :     protected $filterSet = array();
          81                 :
          82                 :     /**
          83                 :      * Constructor
          84                 :      *
          85                 :      * Loads filters based on provided IDS_Init settings.
          86                 :      *
          87                 :      * @param object $init IDS_Init instance
          88                 :      *
          89                 :      * @throws Exception if unsupported filter type is given
          90                 :      * @return void
          91                 :      */
          92                 :     public final function __construct(IDS_Init $init)
          93                 :     {
          94              42 :         if ($init->config) {
          95                 :
          96              42 :             $caching = isset($init->config['Caching']['caching']) ?
          97              42 :                 $init->config['Caching']['caching'] : 'none';
          98                 :
          99              42 :             $type         = $init->config['General']['filter_type'];
         100              42 :             $this->source = $init->getBasePath()
         101              42 :                 . $init->config['General']['filter_path'];
         102                 :
         103              42 :             if ($caching && $caching != 'none') {
         104              42 :                 $this->cacheSettings = $init->config['Caching'];
         105              42 :                 include_once 'IDS/Caching/Factory.php';
         106              42 :                 $this->cache = IDS_Caching::factory($init, 'storage');
         107              42 :             }
         108                 :
         109                 :             switch ($type) {
         110              42 :             case 'xml' :
         111              41 :                 $this->getFilterFromXML();
         112              41 :                 break;
         113               1 :             case 'json' :
         114               1 :                 $this->getFilterFromJson();
         115               1 :                 break;
         116               0 :             default :
         117               0 :                 throw new Exception('Unsupported filter type.');
         118               0 :             }
         119              42 :         }
         120              42 :     }
         121                 :
         122                 :     /**
         123                 :      * Sets the filter array
         124                 :      *
         125                 :      * @param array $filterSet array containing multiple IDS_Filter instances
         126                 :      *
         127                 :      * @return object $this
         128                 :      */
         129                 :     public final function setFilterSet($filterSet)
         130                 :     {
         131               1 :         foreach ($filterSet as $filter) {
         132               1 :             $this->addFilter($filter);
         133               1 :         }
         134                 :
         135               1 :         return $this;
         136                 :     }
         137                 :
         138                 :     /**
         139                 :      * Returns registered filters
         140                 :      *
         141                 :      * @return array
         142                 :      */
         143                 :     public final function getFilterSet()
         144                 :     {
         145              35 :         return $this->filterSet;
         146                 :     }
         147                 :
         148                 :     /**
         149                 :      * Adds a filter
         150                 :      *
         151                 :      * @param object $filter IDS_Filter instance
         152                 :      *
         153                 :      * @return object $this
         154                 :      */
         155                 :     public final function addFilter(IDS_Filter $filter)
         156                 :     {
         157              42 :         $this->filterSet[] = $filter;
         158              42 :         return $this;
         159                 :     }
         160                 :
         161                 :     /**
         162                 :      * Checks if any filters are cached
         163                 :      *
         164                 :      * @return mixed $filters cached filters or false
         165                 :      */
         166                 :     private function _isCached()
         167                 :     {
         168              42 :         $filters = false;
         169                 :
         170              42 :         if ($this->cacheSettings) {
         171                 :
         172              42 :             if ($this->cache) {
         173              42 :                 $filters = $this->cache->getCache();
         174              42 :             }
         175              42 :         }
         176                 :
         177              42 :         return $filters;
         178                 :     }
         179                 :
         180                 :     /**
         181                 :      * Loads filters from XML using SimpleXML
         182                 :      *
         183                 :      * This function parses the provided source file and stores the result.
         184                 :      * If caching mode is enabled the result will be cached to increase
         185                 :      * the performance.
         186                 :      *
         187                 :      * @throws Exception if problems with fetching the XML data occur
         188                 :      * @return object $this
         189                 :      */
         190                 :     public function getFilterFromXML()
         191                 :     {
         192                 :
         193              41 :         if (extension_loaded('SimpleXML')) {
         194                 :
         195                 :             /*
         196                 :              * See if filters are already available in the cache
         197                 :              */
         198              41 :             $filters = $this->_isCached();
         199                 :
         200                 :             /*
         201                 :              * If they aren't, parse the source file
         202                 :              */
         203              41 :             if (!$filters) {
         204               1 :                 if (file_exists($this->source)) {
         205               1 :                     if (LIBXML_VERSION >= 20621) {
         206               1 :                         $filters = simplexml_load_file($this->source,
         207               1 :                                                        null,
         208               1 :                                                        LIBXML_COMPACT);
         209               1 :                     } else {
         210               0 :                         $filters = simplexml_load_file($this->source);
         211                 :                     }
         212               1 :                 }
         213               1 :             }
         214                 :
         215                 :             /*
         216                 :              * In case we still don't have any filters loaded and exception
         217                 :              * will be thrown
         218                 :              */
         219              41 :             if (empty($filters)) {
         220               0 :                 throw new Exception(
         221                 :                     'XML data could not be loaded.' .
         222                 :                         ' Make sure you specified the correct path.'
         223               0 :                 );
         224                 :             }
         225                 :
         226                 :             /*
         227                 :              * Now the storage will be filled with IDS_Filter objects
         228                 :              */
         229              41 :             $data    = array();
         230              41 :             $nocache = $filters instanceof SimpleXMLElement;
         231              41 :             $filters = $nocache ? $filters->filter : $filters;
         232                 :
         233              41 :             include_once 'IDS/Filter.php';
         234                 :
         235              41 :             foreach ($filters as $filter) {
         236                 :
         237              41 :                 $id          = $nocache ? (string) $filter->id :
         238              41 :                     $filter['id'];
         239              41 :                 $rule        = $nocache ? (string) $filter->rule :
         240              41 :                     $filter['rule'];
         241              41 :                 $impact      = $nocache ? (string) $filter->impact :
         242              41 :                     $filter['impact'];
         243              41 :                 $tags        = $nocache ? array_values((array) $filter->tags) :
         244              41 :                     $filter['tags'];
         245              41 :                 $description = $nocache ? (string) $filter->description :
         246              41 :                     $filter['description'];
         247                 :
         248              41 :                 $this->addFilter(new IDS_Filter($id,
         249              41 :                                                 $rule,
         250              41 :                                                 $description,
         251              41 :                                                 (array) $tags[0],
         252              41 :                                                 (int) $impact));
         253                 :
         254              41 :                 $data[] = array(
         255              41 :                     'id'          => $id,
         256              41 :                     'rule'        => $rule,
         257              41 :                     'impact'      => $impact,
         258              41 :                     'tags'        => $tags,
         259                 :                     'description' => $description
         260              41 :                 );
         261              41 :             }
         262                 :
         263                 :             /*
         264                 :              * If caching is enabled, the fetched data will be cached
         265                 :              */
         266              41 :             if ($this->cacheSettings) {
         267                 :
         268              41 :                 $this->cache->setCache($data);
         269              41 :             }
         270                 :
         271              41 :         } else {
         272               0 :             throw new Exception(
         273                 :                 'SimpleXML not loaded.'
         274               0 :             );
         275                 :         }
         276                 :
         277              41 :         return $this;
         278                 :     }
         279                 :
         280                 :     /**
         281                 :      * Loads filters from Json file using ext/Json
         282                 :      *
         283                 :      * This function parses the provided source file and stores the result.
         284                 :      * If caching mode is enabled the result will be cached to increase
         285                 :      * the performance.
         286                 :      *
         287                 :      * @throws Exception if problems with fetching the JSON data occur
         288                 :      * @return object $this
         289                 :      */
         290                 :     public function getFilterFromJson()
         291                 :     {
         292                 :
         293               1 :         if (extension_loaded('Json')) {
         294                 :
         295                 :             /*
         296                 :              * See if filters are already available in the cache
         297                 :              */
         298               1 :             $filters = $this->_isCached();
         299                 :
         300                 :             /*
         301                 :              * If they aren't, parse the source file
         302                 :              */
         303               1 :             if (!$filters) {
         304               0 :                 if (file_exists($this->source)) {
         305               0 :                     @set_magic_quotes_runtime(0);
         306               0 :                     $content = file_get_contents($this->source);
         307               0 :                     $filters = json_decode($content);
         308               0 :                 } else {
         309               0 :                     throw new Exception(
         310                 :                         'JSON data could not be loaded.' .
         311                 :                             ' Make sure you specified the correct path.'
         312               0 :                     );
         313                 :                 }
         314               0 :             }
         315                 :
         316               1 :             if (!$filters) {
         317               0 :                 throw new Exception(
         318                 :                     'JSON data could not be loaded.' .
         319                 :                         ' Make sure you specified the correct path.'
         320               0 :                 );
         321                 :             }
         322                 :
         323                 :             /*
         324                 :              * Now the storage will be filled with IDS_Filter objects
         325                 :              */
         326               1 :             $data    = array();
         327               1 :             $nocache = !is_array($filters);
         328               1 :             $filters = $nocache ? $filters->filters->filter : $filters;
         329                 :
         330               1 :             include_once 'IDS/Filter.php';
         331                 :
         332               1 :             foreach ($filters as $filter) {
         333                 :
         334               1 :                 $id          = $nocache ? (string) $filter->id :
         335               1 :                     $filter['id'];
         336               1 :                 $rule        = $nocache ? (string) $filter->rule :
         337               1 :                     $filter['rule'];
         338               1 :                 $impact      = $nocache ? (string) $filter->impact :
         339               1 :                     $filter['impact'];
         340               1 :                 $tags        = $nocache ? array_values((array) $filter->tags) :
         341               1 :                     $filter['tags'];
         342               1 :                 $description = $nocache ? (string) $filter->description :
         343               1 :                     $filter['description'];
         344                 :
         345               1 :                 $this->addFilter(new IDS_Filter($id,
         346               1 :                                                 $rule,
         347               1 :                                                 $description,
         348               1 :                                                 (array) $tags[0],
         349               1 :                                                 (int) $impact));
         350                 :
         351               1 :                 $data[] = array(
         352               1 :                     'id'          => $id,
         353               1 :                     'rule'        => $rule,
         354               1 :                     'impact'      => $impact,
         355               1 :                     'tags'        => $tags,
         356                 :                     'description' => $description
         357               1 :                 );
         358               1 :             }
         359                 :
         360                 :             /*
         361                 :              * If caching is enabled, the fetched data will be cached
         362                 :              */
         363               1 :             if ($this->cacheSettings) {
         364               1 :                 $this->cache->setCache($data);
         365               1 :             }
         366                 :
         367               1 :         } else {
         368               0 :             throw new Exception(
         369                 :                 'ext/json not loaded.'
         370               0 :             );
         371                 :         }
         372                 :
         373               1 :         return $this;
         374                 :     }
         375                 : }
         376                 :
         377                 : /*
         378                 :  * Local variables:
         379                 :  * tab-width: 4
         380                 :  * c-basic-offset: 4
         381                 :  * End:
         382                 :  */

Generated by PHPUnit 3.3.1 and Xdebug 2.1.0-dev at Mon Dec 22 13:57:42 CET 2008.