Joomla! Platform 12.1

Download

Demo

Source code for file /libraries/joomla/filter/input.php

Documentation is available at input.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Platform
  4.  * @subpackage  Filter
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2012 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. /**
  13.  * JFilterInput is a class for filtering input from any data source
  14.  *
  15.  * Forked from the php input filter library by: Daniel Morris <dan@rootcube.com>
  16.  * Original Contributors: Gianpaolo Racca, Ghislain Picard, Marco Wandschneider, Chris Tobin and Andrew Eddie.
  17.  *
  18.  * @package     Joomla.Platform
  19.  * @subpackage  Filter
  20.  * @since       11.1
  21.  */
  22. class JFilterInput
  23. {
  24.     /**
  25.      * @var    array  A container for JFilterInput instances.
  26.      * @since  11.3
  27.      */
  28.     protected static $instances = array();
  29.  
  30.     /**
  31.      * @var    array  An array of permitted tags.
  32.      * @since  11.1
  33.      */
  34.     public $tagsArray;
  35.  
  36.     /**
  37.      * @var    array  An array of permitted tag attributes.
  38.      * @since  11.1
  39.      */
  40.     public $attrArray;
  41.  
  42.     /**
  43.      * @var    integer  Method for tags: WhiteList method = 0 (default), BlackList method = 1
  44.      * @since  11.1
  45.      */
  46.     public $tagsMethod;
  47.  
  48.     /**
  49.      * @var    integer  Method for attributes: WhiteList method = 0 (default), BlackList method = 1
  50.      * @since  11.1
  51.      */
  52.     public $attrMethod;
  53.  
  54.     /**
  55.      * @var    integer  Only auto clean essentials = 0, Allow clean blacklisted tags/attr = 1
  56.      * @since  11.1
  57.      */
  58.     public $xssAuto;
  59.  
  60.     /**
  61.      * @var    array  A list of the default blacklisted tags.
  62.      * @since  11.1
  63.      */
  64.     public $tagBlacklist = array(
  65.         'applet',
  66.         'body',
  67.         'bgsound',
  68.         'base',
  69.         'basefont',
  70.         'embed',
  71.         'frame',
  72.         'frameset',
  73.         'head',
  74.         'html',
  75.         'id',
  76.         'iframe',
  77.         'ilayer',
  78.         'layer',
  79.         'link',
  80.         'meta',
  81.         'name',
  82.         'object',
  83.         'script',
  84.         'style',
  85.         'title',
  86.         'xml'
  87.     );
  88.  
  89.     /**
  90.      * @var    array     A list of the default blacklisted tag attributes.  All event handlers implicit.
  91.      * @since   11.1
  92.      */
  93.     public $attrBlacklist = array(
  94.         'action',
  95.         'background',
  96.         'codebase',
  97.         'dynsrc',
  98.         'lowsrc'
  99.     );
  100.  
  101.     /**
  102.      * Constructor for inputFilter class. Only first parameter is required.
  103.      *
  104.      * @param   array    $tagsArray   List of user-defined tags
  105.      * @param   array    $attrArray   List of user-defined attributes
  106.      * @param   integer  $tagsMethod  WhiteList method = 0, BlackList method = 1
  107.      * @param   integer  $attrMethod  WhiteList method = 0, BlackList method = 1
  108.      * @param   integer  $xssAuto     Only auto clean essentials = 0, Allow clean blacklisted tags/attr = 1
  109.      *
  110.      * @since   11.1
  111.      */
  112.     public function __construct($tagsArray = array(), $attrArray = array(), $tagsMethod = 0, $attrMethod = 0, $xssAuto = 1)
  113.     {
  114.         // Make sure user defined arrays are in lowercase
  115.         $tagsArray = array_map('strtolower', (array) $tagsArray);
  116.         $attrArray = array_map('strtolower', (array) $attrArray);
  117.  
  118.         // Assign member variables
  119.         $this->tagsArray = $tagsArray;
  120.         $this->attrArray = $attrArray;
  121.         $this->tagsMethod = $tagsMethod;
  122.         $this->attrMethod = $attrMethod;
  123.         $this->xssAuto = $xssAuto;
  124.     }
  125.  
  126.     /**
  127.      * Returns an input filter object, only creating it if it doesn't already exist.
  128.      *
  129.      * @param   array    $tagsArray   List of user-defined tags
  130.      * @param   array    $attrArray   List of user-defined attributes
  131.      * @param   integer  $tagsMethod  WhiteList method = 0, BlackList method = 1
  132.      * @param   integer  $attrMethod  WhiteList method = 0, BlackList method = 1
  133.      * @param   integer  $xssAuto     Only auto clean essentials = 0, Allow clean blacklisted tags/attr = 1
  134.      *
  135.      * @return  JFilterInput  The JFilterInput object.
  136.      *
  137.      * @since   11.1
  138.      */
  139.     public static function &getInstance($tagsArray = array(), $attrArray = array(), $tagsMethod = 0, $attrMethod = 0, $xssAuto = 1)
  140.     {
  141.         $sig = md5(serialize(array($tagsArray, $attrArray, $tagsMethod, $attrMethod, $xssAuto)));
  142.  
  143.         if (empty(self::$instances[$sig]))
  144.         {
  145.             self::$instances[$sig] = new JFilterInput($tagsArray, $attrArray, $tagsMethod, $attrMethod, $xssAuto);
  146.         }
  147.  
  148.         return self::$instances[$sig];
  149.     }
  150.  
  151.     /**
  152.      * Method to be called by another php script. Processes for XSS and
  153.      * specified bad code.
  154.      *
  155.      * @param   mixed   $source  Input string/array-of-string to be 'cleaned'
  156.      * @param   string  $type    Return type for the variable (INT, UINT, FLOAT, BOOLEAN, WORD, ALNUM, CMD, BASE64, STRING, ARRAY, PATH, NONE)
  157.      *
  158.      * @return  mixed  'Cleaned' version of input parameter
  159.      *
  160.      * @since   11.1
  161.      */
  162.     public function clean($source, $type = 'string')
  163.     {
  164.         // Handle the type constraint
  165.         switch (strtoupper($type))
  166.         {
  167.             case 'INT':
  168.             case 'INTEGER':
  169.                 // Only use the first integer value
  170.                 preg_match('/-?[0-9]+/', (string) $source, $matches);
  171.                 $result = @ (int) $matches[0];
  172.                 break;
  173.  
  174.             case 'UINT':
  175.                 // Only use the first integer value
  176.                 preg_match('/-?[0-9]+/', (string) $source, $matches);
  177.                 $result = @ abs((int) $matches[0]);
  178.                 break;
  179.  
  180.             case 'FLOAT':
  181.             case 'DOUBLE':
  182.                 // Only use the first floating point value
  183.                 preg_match('/-?[0-9]+(\.[0-9]+)?/', (string) $source, $matches);
  184.                 $result = @ (float) $matches[0];
  185.                 break;
  186.  
  187.             case 'BOOL':
  188.             case 'BOOLEAN':
  189.                 $result = (bool) $source;
  190.                 break;
  191.  
  192.             case 'WORD':
  193.                 $result = (string) preg_replace('/[^A-Z_]/i', '', $source);
  194.                 break;
  195.  
  196.             case 'ALNUM':
  197.                 $result = (string) preg_replace('/[^A-Z0-9]/i', '', $source);
  198.                 break;
  199.  
  200.             case 'CMD':
  201.                 $result = (string) preg_replace('/[^A-Z0-9_\.-]/i', '', $source);
  202.                 $result = ltrim($result, '.');
  203.                 break;
  204.  
  205.             case 'BASE64':
  206.                 $result = (string) preg_replace('/[^A-Z0-9\/+=]/i', '', $source);
  207.                 break;
  208.  
  209.             case 'STRING':
  210.                 $result = (string) $this->_remove($this->_decode((string) $source));
  211.                 break;
  212.  
  213.             case 'HTML':
  214.                 $result = (string) $this->_remove((string) $source);
  215.                 break;
  216.  
  217.             case 'ARRAY':
  218.                 $result = (array) $source;
  219.                 break;
  220.  
  221.             case 'PATH':
  222.                 $pattern = '/^[A-Za-z0-9_-]+[A-Za-z0-9_\.-]*([\\\\\/][A-Za-z0-9_-]+[A-Za-z0-9_\.-]*)*$/';
  223.                 preg_match($pattern, (string) $source, $matches);
  224.                 $result = @ (string) $matches[0];
  225.                 break;
  226.  
  227.             case 'USERNAME':
  228.                 $result = (string) preg_replace('/[\x00-\x1F\x7F<>"\'%&]/', '', $source);
  229.                 break;
  230.  
  231.             default:
  232.                 // Are we dealing with an array?
  233.                 if (is_array($source))
  234.                 {
  235.                     foreach ($source as $key => $value)
  236.                     {
  237.                         // Filter element for XSS and other 'bad' code etc.
  238.                         if (is_string($value))
  239.                         {
  240.                             $source[$key] = $this->_remove($this->_decode($value));
  241.                         }
  242.                     }
  243.                     $result = $source;
  244.                 }
  245.                 else
  246.                 {
  247.                     // Or a string?
  248.                     if (is_string($source) && !empty($source))
  249.                     {
  250.                         // Filter source for XSS and other 'bad' code etc.
  251.                         $result = $this->_remove($this->_decode($source));
  252.                     }
  253.                     else
  254.                     {
  255.                         // Not an array or string.. return the passed parameter
  256.                         $result = $source;
  257.                     }
  258.                 }
  259.                 break;
  260.         }
  261.  
  262.         return $result;
  263.     }
  264.  
  265.     /**
  266.      * Function to determine if contents of an attribute are safe
  267.      *
  268.      * @param   array  $attrSubSet  A 2 element array for attribute's name, value
  269.      *
  270.      * @return  boolean  True if bad code is detected
  271.      *
  272.      * @since   11.1
  273.      */
  274.     public static function checkAttribute($attrSubSet)
  275.     {
  276.         $attrSubSet[0] = strtolower($attrSubSet[0]);
  277.         $attrSubSet[1] = strtolower($attrSubSet[1]);
  278.  
  279.         return (((strpos($attrSubSet[1], 'expression') !== false) && ($attrSubSet[0]) == 'style') || (strpos($attrSubSet[1], 'javascript:') !== false) ||
  280.             (strpos($attrSubSet[1], 'behaviour:') !== false) || (strpos($attrSubSet[1], 'vbscript:') !== false) ||
  281.             (strpos($attrSubSet[1], 'mocha:') !== false) || (strpos($attrSubSet[1], 'livescript:') !== false));
  282.     }
  283.  
  284.     /**
  285.      * Internal method to iteratively remove all unwanted tags and attributes
  286.      *
  287.      * @param   string  $source  Input string to be 'cleaned'
  288.      *
  289.      * @return  string  'Cleaned' version of input parameter
  290.      *
  291.      * @since   11.1
  292.      */
  293.     protected function _remove($source)
  294.     {
  295.         $loopCounter = 0;
  296.  
  297.         // Iteration provides nested tag protection
  298.         while ($source != $this->_cleanTags($source))
  299.         {
  300.             $source = $this->_cleanTags($source);
  301.             $loopCounter++;
  302.         }
  303.  
  304.         return $source;
  305.     }
  306.  
  307.     /**
  308.      * Internal method to strip a string of certain tags
  309.      *
  310.      * @param   string  $source  Input string to be 'cleaned'
  311.      *
  312.      * @return  string  'Cleaned' version of input parameter
  313.      *
  314.      * @since   11.1
  315.      */
  316.     protected function _cleanTags($source)
  317.     {
  318.         // First, pre-process this for illegal characters inside attribute values
  319.         $source = $this->_escapeAttributeValues($source);
  320.  
  321.         // In the beginning we don't really have a tag, so everything is postTag
  322.         $preTag = null;
  323.         $postTag = $source;
  324.         $currentSpace = false;
  325.  
  326.         // Setting to null to deal with undefined variables
  327.         $attr = '';
  328.  
  329.         // Is there a tag? If so it will certainly start with a '<'.
  330.         $tagOpen_start = strpos($source, '<');
  331.  
  332.         while ($tagOpen_start !== false)
  333.         {
  334.             // Get some information about the tag we are processing
  335.             $preTag .= substr($postTag, 0, $tagOpen_start);
  336.             $postTag = substr($postTag, $tagOpen_start);
  337.             $fromTagOpen = substr($postTag, 1);
  338.             $tagOpen_end = strpos($fromTagOpen, '>');
  339.  
  340.             // Check for mal-formed tag where we have a second '<' before the first '>'
  341.             $nextOpenTag = (strlen($postTag) > $tagOpen_start) ? strpos($postTag, '<', $tagOpen_start + 1) : false;
  342.             if (($nextOpenTag !== false) && ($nextOpenTag < $tagOpen_end))
  343.             {
  344.                 // At this point we have a mal-formed tag -- remove the offending open
  345.                 $postTag = substr($postTag, 0, $tagOpen_start) . substr($postTag, $tagOpen_start + 1);
  346.                 $tagOpen_start = strpos($postTag, '<');
  347.                 continue;
  348.             }
  349.  
  350.             // Let's catch any non-terminated tags and skip over them
  351.             if ($tagOpen_end === false)
  352.             {
  353.                 $postTag = substr($postTag, $tagOpen_start + 1);
  354.                 $tagOpen_start = strpos($postTag, '<');
  355.                 continue;
  356.             }
  357.  
  358.             // Do we have a nested tag?
  359.             $tagOpen_nested = strpos($fromTagOpen, '<');
  360.             $tagOpen_nested_end = strpos(substr($postTag, $tagOpen_end), '>');
  361.             if (($tagOpen_nested !== false) && ($tagOpen_nested < $tagOpen_end))
  362.             {
  363.                 $preTag .= substr($postTag, 0, ($tagOpen_nested + 1));
  364.                 $postTag = substr($postTag, ($tagOpen_nested + 1));
  365.                 $tagOpen_start = strpos($postTag, '<');
  366.                 continue;
  367.             }
  368.  
  369.             // Let's get some information about our tag and setup attribute pairs
  370.             $tagOpen_nested = (strpos($fromTagOpen, '<') + $tagOpen_start + 1);
  371.             $currentTag = substr($fromTagOpen, 0, $tagOpen_end);
  372.             $tagLength = strlen($currentTag);
  373.             $tagLeft = $currentTag;
  374.             $attrSet = array();
  375.             $currentSpace = strpos($tagLeft, ' ');
  376.  
  377.             // Are we an open tag or a close tag?
  378.             if (substr($currentTag, 0, 1) == '/')
  379.             {
  380.                 // Close Tag
  381.                 $isCloseTag = true;
  382.                 list ($tagName) = explode(' ', $currentTag);
  383.                 $tagName = substr($tagName, 1);
  384.             }
  385.             else
  386.             {
  387.                 // Open Tag
  388.                 $isCloseTag = false;
  389.                 list ($tagName) = explode(' ', $currentTag);
  390.             }
  391.  
  392.             /*
  393.              * Exclude all "non-regular" tagnames
  394.              * OR no tagname
  395.              * OR remove if xssauto is on and tag is blacklisted
  396.              */
  397.             if ((!preg_match("/^[a-z][a-z0-9]*$/i", $tagName)) || (!$tagName) || ((in_array(strtolower($tagName), $this->tagBlacklist)) && ($this->xssAuto)))
  398.             {
  399.                 $postTag = substr($postTag, ($tagLength + 2));
  400.                 $tagOpen_start = strpos($postTag, '<');
  401.  
  402.                 // Strip tag
  403.                 continue;
  404.             }
  405.  
  406.             /*
  407.              * Time to grab any attributes from the tag... need this section in
  408.              * case attributes have spaces in the values.
  409.              */
  410.             while ($currentSpace !== false)
  411.             {
  412.                 $attr = '';
  413.                 $fromSpace = substr($tagLeft, ($currentSpace + 1));
  414.                 $nextEqual = strpos($fromSpace, '=');
  415.                 $nextSpace = strpos($fromSpace, ' ');
  416.                 $openQuotes = strpos($fromSpace, '"');
  417.                 $closeQuotes = strpos(substr($fromSpace, ($openQuotes + 1)), '"') + $openQuotes + 1;
  418.  
  419.                 $startAtt = '';
  420.                 $startAttPosition = 0;
  421.  
  422.                 // Find position of equal and open quotes ignoring
  423.                 if (preg_match('#\s*=\s*\"#', $fromSpace, $matches, PREG_OFFSET_CAPTURE))
  424.                 {
  425.                     $startAtt = $matches[0][0];
  426.                     $startAttPosition = $matches[0][1];
  427.                     $closeQuotes = strpos(substr($fromSpace, ($startAttPosition + strlen($startAtt))), '"') + $startAttPosition + strlen($startAtt);
  428.                     $nextEqual = $startAttPosition + strpos($startAtt, '=');
  429.                     $openQuotes = $startAttPosition + strpos($startAtt, '"');
  430.                     $nextSpace = strpos(substr($fromSpace, $closeQuotes), ' ') + $closeQuotes;
  431.                 }
  432.  
  433.                 // Do we have an attribute to process? [check for equal sign]
  434.                 if ($fromSpace != '/' && (($nextEqual && $nextSpace && $nextSpace < $nextEqual) || !$nextEqual))
  435.                 {
  436.                     if (!$nextEqual)
  437.                     {
  438.                         $attribEnd = strpos($fromSpace, '/') - 1;
  439.                     }
  440.                     else
  441.                     {
  442.                         $attribEnd = $nextSpace - 1;
  443.                     }
  444.                     // If there is an ending, use this, if not, do not worry.
  445.                     if ($attribEnd > 0)
  446.                     {
  447.                         $fromSpace = substr($fromSpace, $attribEnd + 1);
  448.                     }
  449.                 }
  450.                 if (strpos($fromSpace, '=') !== false)
  451.                 {
  452.                     // If the attribute value is wrapped in quotes we need to grab the substring from
  453.                     // the closing quote, otherwise grab until the next space.
  454.                     if (($openQuotes !== false) && (strpos(substr($fromSpace, ($openQuotes + 1)), '"') !== false))
  455.                     {
  456.                         $attr = substr($fromSpace, 0, ($closeQuotes + 1));
  457.                     }
  458.                     else
  459.                     {
  460.                         $attr = substr($fromSpace, 0, $nextSpace);
  461.                     }
  462.                 }
  463.                 // No more equal signs so add any extra text in the tag into the attribute array [eg. checked]
  464.                 else
  465.                 {
  466.                     if ($fromSpace != '/')
  467.                     {
  468.                         $attr = substr($fromSpace, 0, $nextSpace);
  469.                     }
  470.                 }
  471.  
  472.                 // Last Attribute Pair
  473.                 if (!$attr && $fromSpace != '/')
  474.                 {
  475.                     $attr = $fromSpace;
  476.                 }
  477.  
  478.                 // Add attribute pair to the attribute array
  479.                 $attrSet[] = $attr;
  480.  
  481.                 // Move search point and continue iteration
  482.                 $tagLeft = substr($fromSpace, strlen($attr));
  483.                 $currentSpace = strpos($tagLeft, ' ');
  484.             }
  485.  
  486.             // Is our tag in the user input array?
  487.             $tagFound = in_array(strtolower($tagName), $this->tagsArray);
  488.  
  489.             // If the tag is allowed let's append it to the output string.
  490.             if ((!$tagFound && $this->tagsMethod) || ($tagFound && !$this->tagsMethod))
  491.             {
  492.                 // Reconstruct tag with allowed attributes
  493.                 if (!$isCloseTag)
  494.                 {
  495.                     // Open or single tag
  496.                     $attrSet = $this->_cleanAttributes($attrSet);
  497.                     $preTag .= '<' . $tagName;
  498.                     for ($i = 0, $count = count($attrSet); $i < $count; $i++)
  499.                     {
  500.                         $preTag .= ' ' . $attrSet[$i];
  501.                     }
  502.  
  503.                     // Reformat single tags to XHTML
  504.                     if (strpos($fromTagOpen, '</' . $tagName))
  505.                     {
  506.                         $preTag .= '>';
  507.                     }
  508.                     else
  509.                     {
  510.                         $preTag .= ' />';
  511.                     }
  512.                 }
  513.                 // Closing tag
  514.                 else
  515.                 {
  516.                     $preTag .= '</' . $tagName . '>';
  517.                 }
  518.             }
  519.  
  520.             // Find next tag's start and continue iteration
  521.             $postTag = substr($postTag, ($tagLength + 2));
  522.             $tagOpen_start = strpos($postTag, '<');
  523.         }
  524.  
  525.         // Append any code after the end of tags and return
  526.         if ($postTag != '<')
  527.         {
  528.             $preTag .= $postTag;
  529.         }
  530.  
  531.         return $preTag;
  532.     }
  533.  
  534.     /**
  535.      * Internal method to strip a tag of certain attributes
  536.      *
  537.      * @param   array  $attrSet  Array of attribute pairs to filter
  538.      *
  539.      * @return  array  Filtered array of attribute pairs
  540.      *
  541.      * @since   11.1
  542.      */
  543.     protected function _cleanAttributes($attrSet)
  544.     {
  545.         // Initialise variables.
  546.         $newSet = array();
  547.  
  548.         $count = count($attrSet);
  549.  
  550.         // Iterate through attribute pairs
  551.         for ($i = 0; $i < $count; $i++)
  552.         {
  553.             // Skip blank spaces
  554.             if (!$attrSet[$i])
  555.             {
  556.                 continue;
  557.             }
  558.  
  559.             // Split into name/value pairs
  560.             $attrSubSet = explode('=', trim($attrSet[$i]), 2);
  561.  
  562.             // Take the last attribute in case there is an attribute with no value
  563.             $attrSubSet[0] = array_pop(explode(' ', trim($attrSubSet[0])));
  564.  
  565.             // Remove all "non-regular" attribute names
  566.             // AND blacklisted attributes
  567.  
  568.             if ((!preg_match('/[a-z]*$/i', $attrSubSet[0]))
  569.                 || (($this->xssAuto) && ((in_array(strtolower($attrSubSet[0]), $this->attrBlacklist))
  570.                 || (substr($attrSubSet[0], 0, 2) == 'on'))))
  571.             {
  572.                 continue;
  573.             }
  574.  
  575.             // XSS attribute value filtering
  576.             if (isset($attrSubSet[1]))
  577.             {
  578.                 // Trim leading and trailing spaces
  579.                 $attrSubSet[1] = trim($attrSubSet[1]);
  580.  
  581.                 // Strips unicode, hex, etc
  582.                 $attrSubSet[1] = str_replace('&#', '', $attrSubSet[1]);
  583.  
  584.                 // Strip normal newline within attr value
  585.                 $attrSubSet[1] = preg_replace('/[\n\r]/', '', $attrSubSet[1]);
  586.  
  587.                 // Strip double quotes
  588.                 $attrSubSet[1] = str_replace('"', '', $attrSubSet[1]);
  589.  
  590.                 // Convert single quotes from either side to doubles (Single quotes shouldn't be used to pad attr values)
  591.                 if ((substr($attrSubSet[1], 0, 1) == "'") && (substr($attrSubSet[1], (strlen($attrSubSet[1]) - 1), 1) == "'"))
  592.                 {
  593.                     $attrSubSet[1] = substr($attrSubSet[1], 1, (strlen($attrSubSet[1]) - 2));
  594.                 }
  595.                 // Strip slashes
  596.                 $attrSubSet[1] = stripslashes($attrSubSet[1]);
  597.             }
  598.             else
  599.             {
  600.                 continue;
  601.             }
  602.  
  603.             // Autostrip script tags
  604.             if (self::checkAttribute($attrSubSet))
  605.             {
  606.                 continue;
  607.             }
  608.  
  609.             // Is our attribute in the user input array?
  610.             $attrFound = in_array(strtolower($attrSubSet[0]), $this->attrArray);
  611.  
  612.             // If the tag is allowed lets keep it
  613.             if ((!$attrFound && $this->attrMethod) || ($attrFound && !$this->attrMethod))
  614.             {
  615.                 // Does the attribute have a value?
  616.                 if (empty($attrSubSet[1]) === false)
  617.                 {
  618.                     $newSet[] = $attrSubSet[0] . '="' . $attrSubSet[1] . '"';
  619.                 }
  620.                 elseif ($attrSubSet[1] === "0")
  621.                 {
  622.                     // Special Case
  623.                     // Is the value 0?
  624.                     $newSet[] = $attrSubSet[0] . '="0"';
  625.                 }
  626.                 else
  627.                 {
  628.                     // Leave empty attributes alone
  629.                     $newSet[] = $attrSubSet[0] . '=""';
  630.                 }
  631.             }
  632.         }
  633.  
  634.         return $newSet;
  635.     }
  636.  
  637.     /**
  638.      * Try to convert to plaintext
  639.      *
  640.      * @param   string  $source  The source string.
  641.      *
  642.      * @return  string  Plaintext string
  643.      *
  644.      * @since   11.1
  645.      */
  646.     protected function _decode($source)
  647.     {
  648.         static $ttr;
  649.  
  650.         if (!is_array($ttr))
  651.         {
  652.             // Entity decode
  653.             $trans_tbl = get_html_translation_table(HTML_ENTITIES);
  654.             foreach ($trans_tbl as $k => $v)
  655.             {
  656.                 $ttr[$v] = utf8_encode($k);
  657.             }
  658.         }
  659.         $source = strtr($source, $ttr);
  660.  
  661.         // Convert decimal
  662.         $source = preg_replace('/&#(\d+);/me', "utf8_encode(chr(\\1))", $source); // decimal notation
  663.  
  664.         // Convert hex
  665.         $source = preg_replace('/&#x([a-f0-9]+);/mei', "utf8_encode(chr(0x\\1))", $source); // hex notation
  666.         return $source;
  667.     }
  668.  
  669.     /**
  670.      * Escape < > and " inside attribute values
  671.      *
  672.      * @param   string  $source  The source string.
  673.      *
  674.      * @return  string  Filtered string
  675.      *
  676.      * @since    11.1
  677.      */
  678.     protected function _escapeAttributeValues($source)
  679.     {
  680.         $alreadyFiltered = '';
  681.         $remainder = $source;
  682.         $badChars = array('<', '"', '>');
  683.         $escapedChars = array('&lt;', '&quot;', '&gt;');
  684.  
  685.         // Process each portion based on presence of =" and "<space>, "/>, or ">
  686.         // See if there are any more attributes to process
  687.         while (preg_match('#<[^>]*?=\s*?(\"|\')#s', $remainder, $matches, PREG_OFFSET_CAPTURE))
  688.         {
  689.             // Get the portion before the attribute value
  690.             $quotePosition = $matches[0][1];
  691.             $nextBefore = $quotePosition + strlen($matches[0][0]);
  692.  
  693.             // Figure out if we have a single or double quote and look for the matching closing quote
  694.             // Closing quote should be "/>, ">, "<space>, or " at the end of the string
  695.             $quote = substr($matches[0][0], -1);
  696.             $pregMatch = ($quote == '"') ? '#(\"\s*/\s*>|\"\s*>|\"\s+|\"$)#' : "#(\'\s*/\s*>|\'\s*>|\'\s+|\'$)#";
  697.  
  698.             // Get the portion after attribute value
  699.             if (preg_match($pregMatch, substr($remainder, $nextBefore), $matches, PREG_OFFSET_CAPTURE))
  700.             {
  701.                 // We have a closing quote
  702.                 $nextAfter = $nextBefore + $matches[0][1];
  703.             }
  704.             else
  705.             {
  706.                 // No closing quote
  707.                 $nextAfter = strlen($remainder);
  708.             }
  709.             // Get the actual attribute value
  710.             $attributeValue = substr($remainder, $nextBefore, $nextAfter - $nextBefore);
  711.  
  712.             // Escape bad chars
  713.             $attributeValue = str_replace($badChars, $escapedChars, $attributeValue);
  714.             $attributeValue = $this->_stripCSSExpressions($attributeValue);
  715.             $alreadyFiltered .= substr($remainder, 0, $nextBefore) . $attributeValue . $quote;
  716.             $remainder = substr($remainder, $nextAfter + 1);
  717.         }
  718.  
  719.         // At this point, we just have to return the $alreadyFiltered and the $remainder
  720.         return $alreadyFiltered . $remainder;
  721.     }
  722.  
  723.     /**
  724.      * Remove CSS Expressions in the form of <property>:expression(...)
  725.      *
  726.      * @param   string  $source  The source string.
  727.      *
  728.      * @return  string  Filtered string
  729.      *
  730.      * @since   11.1
  731.      */
  732.     protected function _stripCSSExpressions($source)
  733.     {
  734.         // Strip any comments out (in the form of /*...*/)
  735.         $test = preg_replace('#\/\*.*\*\/#U', '', $source);
  736.  
  737.         // Test for :expression
  738.         if (!stripos($test, ':expression'))
  739.         {
  740.             // Not found, so we are done
  741.             $return = $source;
  742.         }
  743.         else
  744.         {
  745.             // At this point, we have stripped out the comments and have found :expression
  746.             // Test stripped string for :expression followed by a '('
  747.             if (preg_match_all('#:expression\s*\(#', $test, $matches))
  748.             {
  749.                 // If found, remove :expression
  750.                 $test = str_ireplace(':expression', '', $test);
  751.                 $return = $test;
  752.             }
  753.         }
  754.         return $return;
  755.     }
  756. }
Support Joomla!
/html>