www.aleph1.co.uk Git - yaffs-website/blob - vendor/ezyang/htmlpurifier/library/HTMLPurifier/Filter/ExtractStyleBlocks.php

   1 <?php
   2
   3 // why is this a top level function? Because PHP 5.2.0 doesn't seem to
   4 // understand how to interpret this filter if it's a static method.
   5 // It's all really silly, but if we go this route it might be reasonable
   6 // to coalesce all of these methods into one.
   7 function htmlpurifier_filter_extractstyleblocks_muteerrorhandler()
   8 {
   9 }
  10
  11 /**
  12  * This filter extracts <style> blocks from input HTML, cleans them up
  13  * using CSSTidy, and then places them in $purifier->context->get('StyleBlocks')
  14  * so they can be used elsewhere in the document.
  15  *
  16  * @note
  17  *      See tests/HTMLPurifier/Filter/ExtractStyleBlocksTest.php for
  18  *      sample usage.
  19  *
  20  * @note
  21  *      This filter can also be used on stylesheets not included in the
  22  *      document--something purists would probably prefer. Just directly
  23  *      call HTMLPurifier_Filter_ExtractStyleBlocks->cleanCSS()
  24  */
  25 class HTMLPurifier_Filter_ExtractStyleBlocks extends HTMLPurifier_Filter
  26 {
  27     /**
  28      * @type string
  29      */
  30     public $name = 'ExtractStyleBlocks';
  31
  32     /**
  33      * @type array
  34      */
  35     private $_styleMatches = array();
  36
  37     /**
  38      * @type csstidy
  39      */
  40     private $_tidy;
  41
  42     /**
  43      * @type HTMLPurifier_AttrDef_HTML_ID
  44      */
  45     private $_id_attrdef;
  46
  47     /**
  48      * @type HTMLPurifier_AttrDef_CSS_Ident
  49      */
  50     private $_class_attrdef;
  51
  52     /**
  53      * @type HTMLPurifier_AttrDef_Enum
  54      */
  55     private $_enum_attrdef;
  56
  57     public function __construct()
  58     {
  59         $this->_tidy = new csstidy();
  60         $this->_tidy->set_cfg('lowercase_s', false);
  61         $this->_id_attrdef = new HTMLPurifier_AttrDef_HTML_ID(true);
  62         $this->_class_attrdef = new HTMLPurifier_AttrDef_CSS_Ident();
  63         $this->_enum_attrdef = new HTMLPurifier_AttrDef_Enum(
  64             array(
  65                 'first-child',
  66                 'link',
  67                 'visited',
  68                 'active',
  69                 'hover',
  70                 'focus'
  71             )
  72         );
  73     }
  74
  75     /**
  76      * Save the contents of CSS blocks to style matches
  77      * @param array $matches preg_replace style $matches array
  78      */
  79     protected function styleCallback($matches)
  80     {
  81         $this->_styleMatches[] = $matches[1];
  82     }
  83
  84     /**
  85      * Removes inline <style> tags from HTML, saves them for later use
  86      * @param string $html
  87      * @param HTMLPurifier_Config $config
  88      * @param HTMLPurifier_Context $context
  89      * @return string
  90      * @todo Extend to indicate non-text/css style blocks
  91      */
  92     public function preFilter($html, $config, $context)
  93     {
  94         $tidy = $config->get('Filter.ExtractStyleBlocks.TidyImpl');
  95         if ($tidy !== null) {
  96             $this->_tidy = $tidy;
  97         }
  98         // NB: this must be NON-greedy because if we have
  99         // <style>foo</style>  <style>bar</style>
 100         // we must not grab foo</style>  <style>bar
 101         $html = preg_replace_callback('#<style(?:\s.*)?>(.*)<\/style>#isU', array($this, 'styleCallback'), $html);
 102         $style_blocks = $this->_styleMatches;
 103         $this->_styleMatches = array(); // reset
 104         $context->register('StyleBlocks', $style_blocks); // $context must not be reused
 105         if ($this->_tidy) {
 106             foreach ($style_blocks as &$style) {
 107                 $style = $this->cleanCSS($style, $config, $context);
 108             }
 109         }
 110         return $html;
 111     }
 112
 113     /**
 114      * Takes CSS (the stuff found in <style>) and cleans it.
 115      * @warning Requires CSSTidy <http://csstidy.sourceforge.net/>
 116      * @param string $css CSS styling to clean
 117      * @param HTMLPurifier_Config $config
 118      * @param HTMLPurifier_Context $context
 119      * @throws HTMLPurifier_Exception
 120      * @return string Cleaned CSS
 121      */
 122     public function cleanCSS($css, $config, $context)
 123     {
 124         // prepare scope
 125         $scope = $config->get('Filter.ExtractStyleBlocks.Scope');
 126         if ($scope !== null) {
 127             $scopes = array_map('trim', explode(',', $scope));
 128         } else {
 129             $scopes = array();
 130         }
 131         // remove comments from CSS
 132         $css = trim($css);
 133         if (strncmp('<!--', $css, 4) === 0) {
 134             $css = substr($css, 4);
 135         }
 136         if (strlen($css) > 3 && substr($css, -3) == '-->') {
 137             $css = substr($css, 0, -3);
 138         }
 139         $css = trim($css);
 140         set_error_handler('htmlpurifier_filter_extractstyleblocks_muteerrorhandler');
 141         $this->_tidy->parse($css);
 142         restore_error_handler();
 143         $css_definition = $config->getDefinition('CSS');
 144         $html_definition = $config->getDefinition('HTML');
 145         $new_css = array();
 146         foreach ($this->_tidy->css as $k => $decls) {
 147             // $decls are all CSS declarations inside an @ selector
 148             $new_decls = array();
 149             foreach ($decls as $selector => $style) {
 150                 $selector = trim($selector);
 151                 if ($selector === '') {
 152                     continue;
 153                 } // should not happen
 154                 // Parse the selector
 155                 // Here is the relevant part of the CSS grammar:
 156                 //
 157                 // ruleset
 158                 //   : selector [ ',' S* selector ]* '{' ...
 159                 // selector
 160                 //   : simple_selector [ combinator selector | S+ [ combinator? selector ]? ]?
 161                 // combinator
 162                 //   : '+' S*
 163                 //   : '>' S*
 164                 // simple_selector
 165                 //   : element_name [ HASH | class | attrib | pseudo ]*
 166                 //   | [ HASH | class | attrib | pseudo ]+
 167                 // element_name
 168                 //   : IDENT | '*'
 169                 //   ;
 170                 // class
 171                 //   : '.' IDENT
 172                 //   ;
 173                 // attrib
 174                 //   : '[' S* IDENT S* [ [ '=' | INCLUDES | DASHMATCH ] S*
 175                 //     [ IDENT | STRING ] S* ]? ']'
 176                 //   ;
 177                 // pseudo
 178                 //   : ':' [ IDENT | FUNCTION S* [IDENT S*]? ')' ]
 179                 //   ;
 180                 //
 181                 // For reference, here are the relevant tokens:
 182                 //
 183                 // HASH         #{name}
 184                 // IDENT        {ident}
 185                 // INCLUDES     ==
 186                 // DASHMATCH    |=
 187                 // STRING       {string}
 188                 // FUNCTION     {ident}\(
 189                 //
 190                 // And the lexical scanner tokens
 191                 //
 192                 // name         {nmchar}+
 193                 // nmchar       [_a-z0-9-]|{nonascii}|{escape}
 194                 // nonascii     [\240-\377]
 195                 // escape       {unicode}|\\[^\r\n\f0-9a-f]
 196                 // unicode      \\{h}}{1,6}(\r\n|[ \t\r\n\f])?
 197                 // ident        -?{nmstart}{nmchar*}
 198                 // nmstart      [_a-z]|{nonascii}|{escape}
 199                 // string       {string1}|{string2}
 200                 // string1      \"([^\n\r\f\\"]|\\{nl}|{escape})*\"
 201                 // string2      \'([^\n\r\f\\"]|\\{nl}|{escape})*\'
 202                 //
 203                 // We'll implement a subset (in order to reduce attack
 204                 // surface); in particular:
 205                 //
 206                 //      - No Unicode support
 207                 //      - No escapes support
 208                 //      - No string support (by proxy no attrib support)
 209                 //      - element_name is matched against allowed
 210                 //        elements (some people might find this
 211                 //        annoying...)
 212                 //      - Pseudo-elements one of :first-child, :link,
 213                 //        :visited, :active, :hover, :focus
 214
 215                 // handle ruleset
 216                 $selectors = array_map('trim', explode(',', $selector));
 217                 $new_selectors = array();
 218                 foreach ($selectors as $sel) {
 219                     // split on +, > and spaces
 220                     $basic_selectors = preg_split('/\s*([+> ])\s*/', $sel, -1, PREG_SPLIT_DELIM_CAPTURE);
 221                     // even indices are chunks, odd indices are
 222                     // delimiters
 223                     $nsel = null;
 224                     $delim = null; // guaranteed to be non-null after
 225                     // two loop iterations
 226                     for ($i = 0, $c = count($basic_selectors); $i < $c; $i++) {
 227                         $x = $basic_selectors[$i];
 228                         if ($i % 2) {
 229                             // delimiter
 230                             if ($x === ' ') {
 231                                 $delim = ' ';
 232                             } else {
 233                                 $delim = ' ' . $x . ' ';
 234                             }
 235                         } else {
 236                             // simple selector
 237                             $components = preg_split('/([#.:])/', $x, -1, PREG_SPLIT_DELIM_CAPTURE);
 238                             $sdelim = null;
 239                             $nx = null;
 240                             for ($j = 0, $cc = count($components); $j < $cc; $j++) {
 241                                 $y = $components[$j];
 242                                 if ($j === 0) {
 243                                     if ($y === '*' || isset($html_definition->info[$y = strtolower($y)])) {
 244                                         $nx = $y;
 245                                     } else {
 246                                         // $nx stays null; this matters
 247                                         // if we don't manage to find
 248                                         // any valid selector content,
 249                                         // in which case we ignore the
 250                                         // outer $delim
 251                                     }
 252                                 } elseif ($j % 2) {
 253                                     // set delimiter
 254                                     $sdelim = $y;
 255                                 } else {
 256                                     $attrdef = null;
 257                                     if ($sdelim === '#') {
 258                                         $attrdef = $this->_id_attrdef;
 259                                     } elseif ($sdelim === '.') {
 260                                         $attrdef = $this->_class_attrdef;
 261                                     } elseif ($sdelim === ':') {
 262                                         $attrdef = $this->_enum_attrdef;
 263                                     } else {
 264                                         throw new HTMLPurifier_Exception('broken invariant sdelim and preg_split');
 265                                     }
 266                                     $r = $attrdef->validate($y, $config, $context);
 267                                     if ($r !== false) {
 268                                         if ($r !== true) {
 269                                             $y = $r;
 270                                         }
 271                                         if ($nx === null) {
 272                                             $nx = '';
 273                                         }
 274                                         $nx .= $sdelim . $y;
 275                                     }
 276                                 }
 277                             }
 278                             if ($nx !== null) {
 279                                 if ($nsel === null) {
 280                                     $nsel = $nx;
 281                                 } else {
 282                                     $nsel .= $delim . $nx;
 283                                 }
 284                             } else {
 285                                 // delimiters to the left of invalid
 286                                 // basic selector ignored
 287                             }
 288                         }
 289                     }
 290                     if ($nsel !== null) {
 291                         if (!empty($scopes)) {
 292                             foreach ($scopes as $s) {
 293                                 $new_selectors[] = "$s $nsel";
 294                             }
 295                         } else {
 296                             $new_selectors[] = $nsel;
 297                         }
 298                     }
 299                 }
 300                 if (empty($new_selectors)) {
 301                     continue;
 302                 }
 303                 $selector = implode(', ', $new_selectors);
 304                 foreach ($style as $name => $value) {
 305                     if (!isset($css_definition->info[$name])) {
 306                         unset($style[$name]);
 307                         continue;
 308                     }
 309                     $def = $css_definition->info[$name];
 310                     $ret = $def->validate($value, $config, $context);
 311                     if ($ret === false) {
 312                         unset($style[$name]);
 313                     } else {
 314                         $style[$name] = $ret;
 315                     }
 316                 }
 317                 $new_decls[$selector] = $style;
 318             }
 319             $new_css[$k] = $new_decls;
 320         }
 321         // remove stuff that shouldn't be used, could be reenabled
 322         // after security risks are analyzed
 323         $this->_tidy->css = $new_css;
 324         $this->_tidy->import = array();
 325         $this->_tidy->charset = null;
 326         $this->_tidy->namespace = null;
 327         $css = $this->_tidy->print->plain();
 328         // we are going to escape any special characters <>& to ensure
 329         // that no funny business occurs (i.e. </style> in a font-family prop).
 330         if ($config->get('Filter.ExtractStyleBlocks.Escaping')) {
 331             $css = str_replace(
 332                 array('<', '>', '&'),
 333                 array('\3C ', '\3E ', '\26 '),
 334                 $css
 335             );
 336         }
 337         return $css;
 338     }
 339 }
 340
 341 // vim: et sw=4 sts=4