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 <j.boggiano@seld.be>
  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.      * note that all the includePath directories you provide to the Dwoo_Template_File class
  127.      * are automatically marked as safe
  128.      *
  129.      * @param mixed $path a path name or an array of paths
  130.      */
  131.     public function allowDirectory($path)
  132.     {
  133.         if (is_array($path))
  134.             foreach ($path as $dir)
  135.                 $this->allowedDirectories[realpath($dir)] = true;
  136.         else
  137.             $this->allowedDirectories[realpath($path)] = true;
  138.     }
  139.  
  140.     /**
  141.      * removes a directory from the safelist
  142.      *
  143.      * @param mixed $path a path name or an array of paths
  144.      */
  145.     public function disallowDirectory($path)
  146.     {
  147.         if (is_array($path))
  148.             foreach ($path as $dir)
  149.                 unset($this->allowedDirectories[realpath($dir)]);
  150.         else
  151.             unset($this->allowedDirectories[realpath($path)]);
  152.     }
  153.  
  154.     /**
  155.      * returns the list of safe paths, note that the paths are stored in the array
  156.      * keys and not values
  157.      *
  158.      * @return array 
  159.      */
  160.     public function getAllowedDirectories()
  161.     {
  162.         return $this->allowedDirectories;
  163.     }
  164.  
  165.     /**
  166.      * sets the php handling level, defaults to REMOVE
  167.      *
  168.      * @param int $level one of the Dwoo_Security_Policy::PHP_* constants
  169.      */
  170.     public function setPhpHandling($level = self::PHP_REMOVE)
  171.     {
  172.         $this->phpHandling = $level;
  173.     }
  174.  
  175.     /**
  176.      * returns the php handling level
  177.      *
  178.      * @return int the current level, one of the Dwoo_Security_Policy::PHP_* constants
  179.      */
  180.     public function getPhpHandling()
  181.     {
  182.         return $this->phpHandling;
  183.     }
  184.  
  185.     /**
  186.      * sets the constant handling level, defaults to CONST_DISALLOW
  187.      *
  188.      * @param bool $level one of the Dwoo_Security_Policy::CONST_* constants
  189.      */
  190.     public function setConstantHandling($level = self::CONST_DISALLOW)
  191.     {
  192.         $this->constHandling = $level;
  193.     }
  194.  
  195.     /**
  196.      * returns the constant handling level
  197.      *
  198.      * @return bool the current level, one of the Dwoo_Security_Policy::CONST_* constants
  199.      */
  200.     public function getConstantHandling()
  201.     {
  202.         return $this->constHandling;
  203.     }
  204. }

Documentation generated on Sun, 07 Sep 2008 23:57:55 +0200 by phpDocumentor 1.4.0