Source for file Policy.php

Documentation is available at Policy.php

  1. <?php
  2.  
  3. /**
  4.  * represents the security settings of a dwoo instance, it can be passed around to different dwoo instances
  5.  *
  6.  * This software is provided 'as-is', without any express or implied warranty.
  7.  * In no event will the authors be held liable for any damages arising from the use of this software.
  8.  *
  9.  * This file is released under the LGPL
  10.  * "GNU Lesser General Public License"
  11.  * More information can be found here:
  12.  * {@link http://www.gnu.org/copyleft/lesser.html}
  13.  *
  14.  * @author     Jordi Boggiano <[email protected]>
  15.  * @copyright  Copyright (c) 2008, Jordi Boggiano
  16.  * @license    http://www.gnu.org/copyleft/lesser.html  GNU Lesser General Public License
  17.  * @link       http://dwoo.org/
  18.  * @version    0.9.1
  19.  * @date       2008-05-30
  20.  * @package    Dwoo
  21.  */
  22. class Dwoo_Security_Policy
  23. {
  24.     /**#@+
  25.      * php handling constants, defaults to PHP_REMOVE
  26.      *
  27.      * PHP_REMOVE : remove all <?php ?> (+ short tags if your short tags option is on) from the input template
  28.      * PHP_ALLOW : leave them as they are
  29.      * PHP_ENCODE : run htmlentities over them
  30.      *
  31.      * @var int
  32.      */
  33.     const PHP_ENCODE = 1;
  34.     const PHP_REMOVE = 2;
  35.     const PHP_ALLOW = 3;
  36.     /**#@-*/
  37.  
  38.     /**#@+
  39.      * constant handling constants, defaults to CONST_DISALLOW
  40.      *
  41.      * CONST_DISALLOW : throw an error if {$dwoo.const.*} is used in the template
  42.      * CONST_ALLOW : allow {$dwoo.const.*} calls
  43.      */
  44.     const CONST_DISALLOW = false;
  45.     const CONST_ALLOW = true;
  46.     /**#@-*/
  47.  
  48.     /**
  49.      * php functions that are allowed to be used within the template
  50.      *
  51.      * @var array 
  52.      */
  53.     protected $allowedPhpFunctions = array
  54.     (
  55.         'str_repeat', 'number_format', 'htmlentities', 'htmlspecialchars',
  56.         'long2ip', 'strlen', 'list', 'empty', 'count', 'sizeof', 'in_array', 'is_array',
  57.     );
  58.  
  59.     /**
  60.      * paths that are safe to use with include or other file-access plugins
  61.      *
  62.      * @var array 
  63.      */
  64.     protected $allowedDirectories = array();
  65.  
  66.     /**
  67.      * stores the php handling level
  68.      *
  69.      * defaults to Dwoo_Security_Policy::PHP_REMOVE
  70.      *
  71.      * @var int 
  72.      */
  73.     protected $phpHandling = self::PHP_REMOVE;
  74.  
  75.     /**
  76.      * stores the constant handling level
  77.      *
  78.      * defaults to Dwoo_Security_Policy::CONST_DISALLOW
  79.      *
  80.      * @var bool 
  81.      */
  82.     protected $constHandling = self::CONST_DISALLOW;
  83.  
  84.     /**
  85.      * adds a php function to the allowed list
  86.      *
  87.      * @param mixed $func function name or array of function names
  88.      */
  89.     public function allowPhpFunction($func)
  90.     {
  91.         if (is_array($func))
  92.             foreach ($func as $fname)
  93.                 $this->allowedPhpFunctions[strtolower($fname)] = true;
  94.         else
  95.             $this->allowedPhpFunctions[strtolower($func)] = true;
  96.     }
  97.  
  98.     /**
  99.      * removes a php function from the allowed list
  100.      *
  101.      * @param mixed $func function name or array of function names
  102.      */
  103.     public function disallowPhpFunction($func)
  104.     {
  105.         if (is_array($func))
  106.             foreach ($func as $fname)
  107.                 unset($this->allowedPhpFunctions[strtolower($fname)]);
  108.         else
  109.             unset($this->allowedPhpFunctions[strtolower($func)]);
  110.     }
  111.  
  112.     /**
  113.      * returns the list of php functions allowed to run, note that the function names
  114.      * are stored in the array keys and not values
  115.      *
  116.      * @return array 
  117.      */
  118.     public function getAllowedPhpFunctions()
  119.     {
  120.         return $this->allowedPhpFunctions;
  121.     }
  122.  
  123.     /**
  124.      * adds a directory to the safelist for includes and other file-access plugins
  125.      *
  126.      * @param mixed $path a path name or an array of paths
  127.      */
  128.     public function allowDirectory($path)
  129.     {
  130.         if (is_array($path))
  131.             foreach ($path as $dir)
  132.                 $this->allowedDirectories[realpath($dir)] = true;
  133.         else
  134.             $this->allowedDirectories[realpath($path)] = true;
  135.     }
  136.  
  137.     /**
  138.      * removes a directory from the safelist
  139.      *
  140.      * @param mixed $path a path name or an array of paths
  141.      */
  142.     public function disallowDirectory($path)
  143.     {
  144.         if (is_array($path))
  145.             foreach ($path as $dir)
  146.                 unset($this->allowedDirectories[realpath($dir)]);
  147.         else
  148.             unset($this->allowedDirectories[realpath($path)]);
  149.     }
  150.  
  151.     /**
  152.      * returns the list of safe paths, note that the paths are stored in the array
  153.      * keys and not values
  154.      *
  155.      * @return array 
  156.      */
  157.     public function getAllowedDirectories()
  158.     {
  159.         return $this->allowedDirectories;
  160.     }
  161.  
  162.     /**
  163.      * sets the php handling level, defaults to REMOVE
  164.      *
  165.      * @param int $level one of the Dwoo_Security_Policy::PHP_* constants
  166.      */
  167.     public function setPhpHandling($level = self::PHP_REMOVE)
  168.     {
  169.         $this->phpHandling = $level;
  170.     }
  171.  
  172.     /**
  173.      * returns the php handling level
  174.      *
  175.      * @return int the current level, one of the Dwoo_Security_Policy::PHP_* constants
  176.      */
  177.     public function getPhpHandling()
  178.     {
  179.         return $this->phpHandling;
  180.     }
  181.  
  182.     /**
  183.      * sets the constant handling level, defaults to CONST_DISALLOW
  184.      *
  185.      * @param bool $level one of the Dwoo_Security_Policy::CONST_* constants
  186.      */
  187.     public function setConstantHandling($level = self::CONST_DISALLOW)
  188.     {
  189.         $this->constHandling = $level;
  190.     }
  191.  
  192.     /**
  193.      * returns the constant handling level
  194.      *
  195.      * @return bool the current level, one of the Dwoo_Security_Policy::CONST_* constants
  196.      */
  197.     public function getConstantHandling()
  198.     {
  199.         return $this->constHandling;
  200.     }
  201. }

Documentation generated on Sun, 03 Aug 2008 15:12:43 +0200 by phpDocumentor 1.4.0