Changeset 111709 in spip-zone


Ignore:
Timestamp:
Sep 27, 2018, 12:52:19 PM (10 months ago)
Author:
cedric@…
Message:

Mise a jour de SafeHTML pour le support de HTML5 notamment

Location:
_core_/plugins/safehtml
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • _core_/plugins/safehtml/lib/safehtml/classes/safehtml.php

    r111483 r111709  
    99 * @package    SafeHTML
    1010 * @author     Roman Ivanov <thingol@mail.ru>
    11  * @copyright  2004-2005 Roman Ivanov
     11 * @author     Miguel Vazquez Gocobachi <demrit@mx.gnu.org>
     12 * @copyright  2004-2009 Roman Ivanov, Miguel Vazquez Gocobachi
    1213 * @license    http://www.debian.org/misc/bsd.license  BSD License (3 Clause)
    13  * @version    1.3.7
    14  * @link       http://pixel-apes.com/safehtml/
     14 * @version    1.3.10
     15 * @link       https://wackowiki.org/doc/Dev/Projects/SafeHTML
    1516 */
    1617
     
    5354 * @link       http://pear.php.net/package/SafeHTML
    5455 */
     56
    5557class SafeHTML
    5658{
     
    5961     *
    6062     * @var string
    61      * @access private
    62      */
    63     var $_xhtml = '';
     63     */
     64    protected $xhtml = '';
    6465   
    6566    /**
     
    6768     *
    6869     * @var array
    69      * @access private
    70      */
    71     var $_counter = array();
     70     */
     71    protected $counter = array();
    7272   
    7373    /**
     
    7575     *
    7676     * @var array
    77      * @access private
    78      */
    79     var $_stack = array();
     77     */
     78    protected $stack = array();
    8079   
    8180    /**
     
    8382     *
    8483     * @var array
    85      * @access private
    86      */
    87     var $_dcCounter = array();
     84     */
     85    protected $dcCounter = array();
    8886   
    8987    /**
     
    9189     *
    9290     * @var array
    93      * @access private
    94      */
    95     var $_dcStack = array();
     91     */
     92    protected $dcStack = array();
    9693   
    9794    /**
     
    9996     *
    10097     * @var int
    101      * @access private
    102      */
    103     var $_listScope = 0;
     98     */
     99    protected $listScope = 0;
    104100   
    105101    /**
     
    107103     *
    108104     * @var array
    109      * @access private
    110      */
    111     var $_liStack = array();
     105     */
     106    protected $liStack = array();
    112107
    113108    /**
     
    115110     *
    116111     * @var array
    117      * @access private
    118      */
    119     var $_protoRegexps = array();
     112     */
     113    protected $protoRegexps = array();
    120114   
    121115    /**
     
    123117     *
    124118     * @var array
    125      * @access private
    126      */
    127     var $_cssRegexps = array();
     119     */
     120    protected $cssRegexps = array();
    128121
    129122    /**
     
    139132
    140133    /**
     134     * Allowed tags
     135     *
     136     * @var array
     137     */
     138    protected $allowTags = array();
     139
     140
     141    /**
    141142     * List of single tags ("<tag />")
    142143     *
    143144     * @var array
    144      * @access public
    145      */
    146     var $singleTags = array('area', 'br', 'img', 'input', 'hr', 'wbr', );
     145     */
     146    public $singleTags = array('area', 'br', 'img', 'input', 'hr', 'wbr', );
    147147
    148148    /**
     
    150150     *
    151151     * @var array
    152      * @access public
    153      */
    154     var $deleteTags = array(
     152     */
     153    public $deleteTags = array(
    155154        'applet', 'base',   'basefont', 'bgsound', 'blink',  'body',
    156155        'embed',  'frame',  'frameset', 'head',    'html',   'ilayer',
     
    164163     *
    165164     * @var array
    166      * @access public
    167      */
    168     var $deleteTagsContent = array('script', 'style', 'title', 'xml', );
     165     */
     166    public $deleteTagsContent = array('script', 'style', 'title', 'xml', );
    169167
    170168    /**
     
    172170     *
    173171     * @var string
    174      * @access public
    175      */
    176     var $protocolFiltering = 'white';
     172     */
     173    public $protocolFiltering = 'white';
    177174
    178175    /**
     
    180177     *
    181178     * @var array
    182      * @access public
    183      */
    184     var $blackProtocols = array(
     179     */
     180    public $blackProtocols = array(
    185181        'about',   'chrome',     'data',       'disk',     'hcp',     
    186182        'help',    'javascript', 'livescript', 'lynxcgi',  'lynxexec',
     
    194190     *
    195191     * @var array
    196      * @access public
    197      */
    198     var $whiteProtocols = array(
     192     */
     193    public $whiteProtocols = array(
    199194        'ed2k',   'file', 'ftp',  'gopher', 'http',  'https',
    200195        'irc',    'mailto', 'news', 'nntp', 'telnet', 'webcal',
     
    206201     *
    207202     * @var array
    208      * @access public
    209      */
    210     var $protocolAttributes = array(
     203     */
     204    public $protocolAttributes = array(
    211205        'action', 'background', 'codebase', 'dynsrc', 'href', 'lowsrc', 'src', 'formaction',
    212206        );
     
    219213     *
    220214     * @var array
    221      * @access public
    222      */
    223     var $cssKeywords = array(
     215     */
     216    public $cssKeywords = array(
    224217        'absolute', 'behavior',       'behaviour',   'content', 'expression',
    225218        'fixed',    'include-source', 'moz-binding',
     
    230223     *
    231224     * @var array
    232      * @access public
    233225     * @deprecated XHTML does not allow such tags
    234226     */
    235     var $noClose = array();
     227    public $noClose = array();
    236228
    237229    /**
     
    241233     *
    242234     * @var array
    243      * @access public
    244      */
    245     var $closeParagraph = array(
    246         'address', 'blockquote', 'center', 'dd',      'dir',       'div',
    247         'dl',      'dt',         'h1',     'h2',      'h3',        'h4',
    248         'h5',      'h6',         'hr',     'isindex', 'listing',   'marquee',
    249         'menu',    'multicol',   'ol',     'p',       'plaintext', 'pre',
    250         'table',   'ul',         'xmp',
     235     */
     236    public $closeParagraph = array(
     237        'address', 'article',    'aside',     'audio',    'blockquote', 'canvas',
     238        'center',  'dd',         'dir',       'div',      'dl',         'dt',
     239        'figure',  'figcaption', 'footer',    'h1',       'h2',         'h3',
     240        'h4',      'h5',         'h6',        'header',   'hr',         'isindex',
     241        'listing', 'main',       'marquee',   'menu',      'multicol',  'nav',
     242        'ol',      'output',     'p',         'plaintext', 'pre',       'section',
     243        'table',   'ul',         'video',     'xmp',
    251244        );
    252245
     
    255248     *
    256249     * @var array
    257      * @access public
    258      */
    259     var $tableTags = array(
     250     */
     251    public $tableTags = array(
    260252        'caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
    261253        'thead',   'tr',
     
    266258     *
    267259     * @var array
     260     */
     261    public $listTags = array('dir', 'menu', 'ol', 'ul', 'dl', );
     262
     263    /**
     264     * List of dangerous attributes
     265     *
     266     * @var array
     267     */
     268    public $attributes = array('dynsrc', 'id', 'name', );
     269
     270    /**
     271     * List of allowed "namespaced" attributes
     272     *
     273     * @var array
     274     */
     275    public $attributesNS = array('xml:lang', );
     276
     277    /**
     278     * Constructs class
     279     *
    268280     * @access public
    269281     */
    270     var $listTags = array('dir', 'menu', 'ol', 'ul', 'dl', );
    271 
    272     /**
    273      * List of dangerous attributes
    274      *
    275      * @var array
    276      * @access public
    277      */
    278     var $attributes = array('dynsrc', 'id', 'name', );
    279 
    280     /**
    281      * List of allowed "namespaced" attributes
    282      *
    283      * @var array
    284      * @access public
    285      */
    286     var $attributesNS = array('xml:lang', );
    287 
    288     /**
    289      * Constructs class
    290      *
    291      * @access public
    292      */
    293     function __construct()
     282    public function __construct()
    294283    {
    295284        //making regular expressions based on Proto & CSS arrays
     
    300289            }
    301290            $preg .= ":/i";
    302             $this->_protoRegexps[] = $preg;
     291            $this->protoRegexps[] = $preg;
    303292        }
    304293
    305294        foreach ($this->cssKeywords as $css) {
    306             $this->_cssRegexps[] = '/' . $css . '/i';
     295            $this->cssRegexps[] = '/' . $css . '/i';
    307296        }
    308297        return true;
     
    310299
    311300    /**
    312      * Handles the writing of attributes - called from $this->_openHandler()
     301     * Handles the writing of attributes - called from $this->openHandler()
    313302     *
    314303     * @param array $attrs array of attributes $name => $value
     304     * @param string|null $tag
    315305     * @return boolean
    316      * @access private
    317      */
    318     function _writeAttrs ($attrs, $tag = null)
     306     */
     307    protected function writeAttrs ($attrs, $tag = null)
    319308    {
    320309        if (is_array($attrs)) {
    321310            foreach ($attrs as $name => $value) {
    322 
    323311                $name = strtolower($name);
    324312
     
    326314                    continue;
    327315                }
     316
    328317                if (strpos($name, 'data') === 0) {
    329318                    continue;
    330319                }
     320
    331321                if ($tag != 'a' and in_array($name, $this->attributes)) {
    332322                    continue;
    333323                }
    334                 if (!preg_match("/^[a-z0-9]+$/i", $name)) {
    335                     if (!in_array($name, $this->attributesNS))
    336                     {
     324
     325                if (!preg_match('/^[a-z0-9]+$/i', $name)) {
     326                    if (!in_array($name, $this->attributesNS)) {
    337327                        continue;
    338328                    }
    339329                }
    340330
    341                 if (($value === TRUE) || (is_null($value))) {
     331                if (($value === true) || (is_null($value))) {
    342332                    $value = $name;
    343333                }
    344334
    345335                if ($name == 'style') {
    346                    
    347336                   // removes insignificant backslahes
    348337                   $value = str_replace("\\", '', $value);
    349338
    350339                   // removes CSS comments
    351                    while (1)
    352                    {
    353                      $_value = preg_replace("!/\*.*?\*/!s", '', $value);
    354                      if ($_value == $value) break;
     340                   while (1) {
     341                     $_value = preg_replace('!/\*.*?\*/!s', '', $value);
     342
     343                     if ($_value == $value) {
     344                         break;
     345                     }
     346
    355347                     $value = $_value;
    356348                   }
     
    360352                   $value = str_replace('&', '&amp;', $value);
    361353
    362                    foreach ($this->_cssRegexps as $css) {
     354                   foreach ($this->cssRegexps as $css) {
    363355                       if (preg_match($css, $value)) {
    364356                           continue 2;
    365357                       }
    366358                   }
    367                    foreach ($this->_protoRegexps as $proto) {
     359
     360                   foreach ($this->protoRegexps as $proto) {
    368361                       if (preg_match($proto, $value)) {
    369362                           continue 2;
     
    372365                }
    373366
    374                 $tempval = preg_replace_callback('/&#(\d+);?/m', function($m) { return chr($m[1]); }, $value); //"'
    375                 $tempval = preg_replace_callback('/&#x([0-9a-f]+);?/mi', function($m) { return chr(hexdec($m[1])); }, $tempval); //"'
    376 
    377                 if ((in_array($name, $this->protocolAttributes)) &&
    378                     (strpos($tempval, ':') !== false))
    379                 {
     367                $tempval = preg_replace_callback('/&#(\d+);?/m', function ($matches) { return chr($matches[1]); }, $value); //"'
     368                $tempval = preg_replace_callback(
     369                        '/&#x([0-9a-f]+);?/mi',
     370                        function ($matches) { return chr(hexdec($matches[1])); },
     371                    $tempval
     372                );
     373
     374                if ((in_array($name, $this->protocolAttributes))
     375                  && (strpos($tempval, ':') !== false)
     376                ) {
    380377                    if ($this->protocolFiltering == 'black') {
    381                         foreach ($this->_protoRegexps as $proto) {
    382                             if (preg_match($proto, $tempval)) continue 2;
     378                        foreach ($this->protoRegexps as $proto) {
     379                            if (preg_match($proto, $tempval)) {
     380                                continue 2;
     381                            }
    383382                        }
    384383                    } else {
    385384                        $_tempval = explode(':', $tempval);
    386385                        $proto = $_tempval[0];
     386
    387387                        if (!in_array($proto, $this->whiteProtocols)) {
    388388                            continue;
     
    391391                }
    392392
    393                 $value = str_replace("\"", "&quot;", $value);
    394                 $this->_xhtml .= ' ' . $name . '="' . $value . '"';
     393                $value        = str_replace("\"", '&quot;', $value);
     394                $this->xhtml .= ' ' . $name . '="' . $value . '"';
    395395            }
    396396        }
     397
    397398        return true;
    398399    }
     
    401402     * Opening tag handler - called from HTMLSax
    402403     *
    403      * @param object $parser HTML Parser
     404     * @param object &$parser HTML Parser
    404405     * @param string $name   tag name
    405406     * @param array  $attrs  tag attributes
     407     *
    406408     * @return boolean
    407      * @access private
    408      */
    409     function _openHandler(&$parser, $name, $attrs)
     409     */
     410    public function openHandler(&$parser, $name, $attrs)
    410411    {
    411412        $name = strtolower($name);
    412413
    413414        if (in_array($name, $this->deleteTagsContent)) {
    414             array_push($this->_dcStack, $name);
    415             $this->_dcCounter[$name] = isset($this->_dcCounter[$name]) ? $this->_dcCounter[$name]+1 : 1;
    416         }
    417         if (count($this->_dcStack) != 0) {
     415            array_push($this->dcStack, $name);
     416            $this->dcCounter[$name] = isset($this->dcCounter[$name])
     417                ? $this->dcCounter[$name]+1 : 1;
     418        }
     419        if (count($this->dcStack) != 0) {
    418420            return true;
    419421        }
    420422
    421         if (in_array($name, $this->deleteTags)) {
     423        if (in_array($name, $this->deleteTags)
     424            && !in_array($name, $this->allowTags)
     425        ) {
    422426            return true;
    423427        }
    424428       
    425         if (!preg_match("/^[a-z0-9]+$/i", $name)) {
    426             if (preg_match("!(?:\@|://)!i", $name)) {
    427                 $this->_xhtml .= '&lt;' . $name . '&gt;';
     429        if (!preg_match('/^[a-z0-9]+$/i', $name)) {
     430            if (preg_match('!(?:\@|://)!i', $name)) {
     431                $this->xhtml .= '&lt;' . $name . '&gt;';
    428432            }
    429433            return true;
     
    431435
    432436        if (in_array($name, $this->singleTags)) {
    433             $this->_xhtml .= '<' . $name;
    434             $this->_writeAttrs($attrs, $name);
    435             $this->_xhtml .= ' />';
     437            $this->xhtml .= '<' . $name;
     438            $this->writeAttrs($attrs, $name);
     439            $this->xhtml .= ' />';
    436440            return true;
    437441        }
    438442
    439443        // TABLES: cannot open table elements when we are not inside table
    440         if ((isset($this->_counter['table'])) && ($this->_counter['table'] <= 0)
    441             && (in_array($name, $this->tableTags)))
    442         {
     444        if ((isset($this->counter['table']))
     445            && ($this->counter['table'] <= 0)
     446            && (in_array($name, $this->tableTags))
     447        ) {
    443448            return true;
    444449        }
    445450
    446451        // PARAGRAPHS: close paragraph when closeParagraph tags opening
    447         if ((in_array($name, $this->closeParagraph)) && (in_array('p', $this->_stack))) {
    448             $this->_closeHandler($parser, 'p');
     452        if ((in_array($name, $this->closeParagraph))
     453            && (in_array('p', $this->stack))
     454        ) {
     455            $this->closeHandler($parser, 'p');
    449456        }
    450457
    451458        // LISTS: we should close <li> if <li> of the same level opening
    452         if ($name == 'li' && count($this->_liStack) &&
    453             $this->_listScope == $this->_liStack[count($this->_liStack)-1])
    454         {
    455             $this->_closeHandler($parser, 'li');
     459        if (($name == 'li') && count($this->liStack)
     460            && ($this->listScope == $this->liStack[count($this->liStack) - 1])
     461        ) {
     462            $this->closeHandler($parser, 'li');
    456463        }
    457464
    458465        // LISTS: we want to know on what nesting level of lists we are
    459466        if (in_array($name, $this->listTags)) {
    460             $this->_listScope++;
    461         }
     467            ++$this->listScope;
     468        }
     469
    462470        if ($name == 'li') {
    463             array_push($this->_liStack, $this->_listScope);
     471            array_push($this->liStack, $this->listScope);
    464472        }
    465473           
    466         $this->_xhtml .= '<' . $name;
    467         $this->_writeAttrs($attrs, $name);
    468         $this->_xhtml .= '>';
    469         array_push($this->_stack,$name);
    470         $this->_counter[$name] = isset($this->_counter[$name]) ? $this->_counter[$name]+1 : 1;
     474        $this->xhtml .= '<' . $name;
     475        $this->writeAttrs($attrs, $name);
     476        $this->xhtml .= '>';
     477        array_push($this->stack,$name);
     478        $this->counter[$name] = isset($this->counter[$name])
     479            ? ($this->counter[$name] + 1) : 1;
     480
    471481        return true;
    472482    }
     
    475485     * Closing tag handler - called from HTMLSax
    476486     *
    477      * @param object $parsers HTML parser
     487     * @param object &$parser HTML parser
    478488     * @param string $name    tag name
     489     *
    479490     * @return boolean
    480      * @access private
    481      */
    482     function _closeHandler(&$parser, $name)
    483     {
    484 
     491     */
     492    public function closeHandler(&$parser, $name)
     493    {
    485494        $name = strtolower($name);
    486495
    487         if (isset($this->_dcCounter[$name]) && ($this->_dcCounter[$name] > 0) &&
    488             (in_array($name, $this->deleteTagsContent)))
    489         {
    490            while ($name != ($tag = array_pop($this->_dcStack))) {
    491             $this->_dcCounter[$tag]--;
     496        if (isset($this->dcCounter[$name])
     497            && ($this->dcCounter[$name] > 0)
     498            && (in_array($name, $this->deleteTagsContent))
     499        ) {
     500           while ($name != ($tag = array_pop($this->dcStack))) {
     501                --$this->dcCounter[$tag];
    492502           }
    493503
    494            $this->_dcCounter[$name]--;
    495         }
    496 
    497         if (count($this->_dcStack) != 0) {
     504            --$this->dcCounter[$name];
     505        }
     506
     507        if (count($this->dcStack) != 0) {
    498508            return true;
    499509        }
    500510
    501         if ((isset($this->_counter[$name])) && ($this->_counter[$name] > 0)) {
    502            while ($name != ($tag = array_pop($this->_stack))) {
    503                $this->_closeTag($tag);
     511        if ((isset($this->counter[$name])) && ($this->counter[$name] > 0)) {
     512           while ($name != ($tag = array_pop($this->stack))) {
     513                $this->closeTag($tag);
    504514           }
    505515
    506            $this->_closeTag($name);
     516            $this->closeTag($name);
    507517        }
    508518        return true;
     
    513523     *
    514524     * @param string $tag tag name
     525     *
    515526     * @return boolean
    516      * @access private
    517      */
    518     function _closeTag($tag)
     527     */
     528    protected function closeTag($tag)
    519529    {
    520530        if (!in_array($tag, $this->noClose)) {
    521             $this->_xhtml .= '</' . $tag . '>';
    522         }
    523 
    524         $this->_counter[$tag]--;
     531            $this->xhtml .= '</' . $tag . '>';
     532        }
     533
     534        --$this->counter[$tag];
    525535
    526536        if (in_array($tag, $this->listTags)) {
    527             $this->_listScope--;
     537            --$this->listScope;
    528538        }
    529539
    530540        if ($tag == 'li') {
    531             array_pop($this->_liStack);
    532         }
     541            array_pop($this->liStack);
     542        }
     543
    533544        return true;
    534545    }
     
    537548     * Character data handler - called from HTMLSax
    538549     *
    539      * @param object $parser HTML parser
     550     * @param object &$parser HTML parser
    540551     * @param string $data   textual data
     552     *
    541553     * @return boolean
    542      * @access private
    543      */
    544     function _dataHandler(&$parser, $data)
    545     {
    546         if (count($this->_dcStack) == 0) {
    547             $this->_xhtml .= $data;
    548         }
     554     */
     555    public function dataHandler(&$parser, $data)
     556    {
     557        if (count($this->dcStack) == 0) {
     558            $this->xhtml .= $data;
     559        }
     560
    549561        return true;
    550562    }
     
    553565     * Escape handler - called from HTMLSax
    554566     *
    555      * @param object $parser HTML parser
     567     * @param object &$parser HTML parser
    556568     * @param string $data   comments or other type of data
     569     *
    557570     * @return boolean
    558      * @access private
    559      */
    560     function _escapeHandler(&$parser, $data)
     571     */
     572    public function escapeHandler(&$parser, $data)
    561573    {
    562574        return true;
     
    564576
    565577    /**
     578     * Allow tags
     579     *
     580     * Example:
     581     * <pre>
     582     * $safe = new HTML_Safe;
     583     * $safe->setAllowTags(array('body'));
     584     * </pre>
     585     *
     586     * @param array $tags Tags to allow
     587     *
     588     * @return void
     589     */
     590    public function setAllowTags($tags = array())
     591    {
     592        if (is_array($tags)) {
     593            $this->allowTags = $tags;
     594        }
     595    }
     596
     597    /**
     598     * Returns the allowed tags
     599     *
     600     * @return array
     601     */
     602    public function getAllowTags()
     603    {
     604        return $this->allowTags;
     605    }
     606
     607    /**
     608     * Reset the allowed tags
     609     *
     610     * @return void
     611     */
     612    public function resetAllowTags()
     613    {
     614        $this->allowTags = array();
     615    }
     616
     617    /**
    566618     * Returns the XHTML document
    567619     *
    568620     * @return string Processed (X)HTML document
    569      * @access public
    570      */
    571     function getXHTML ()
    572     {
    573         while ($tag = array_pop($this->_stack)) {
    574             $this->_closeTag($tag);
     621     */
     622    public function getXHTML()
     623    {
     624        while ($tag = array_pop($this->stack)) {
     625            $this->closeTag($tag);
    575626        }
    576627       
    577         return $this->_xhtml;
     628        return $this->xhtml;
    578629    }
    579630
     
    582633     *
    583634     * @return boolean
    584      * @access public
    585      */
    586     function clear()
    587     {
    588         $this->_xhtml = '';
     635     */
     636    public function clear()
     637    {
     638        $this->xhtml = '';
    589639        return true;
    590640    }
     
    594644     *
    595645     * @param string $doc HTML document for processing
     646     *
    596647     * @return string Processed (X)HTML document
    597      * @access public
    598      */
    599     function parse($doc)
    600     {
     648     */
     649    public function parse($doc)
     650    {
     651       $result = '';
    601652
    602653       // Save all '<' symbols
    603        $doc = preg_replace("/<(?=[^a-zA-Z\/\!\?\%])/", '&lt;', $doc);
     654       $doc = preg_replace('/<(?=[^a-zA-Z\/\!\?\%])/', '&lt;', $doc);
    604655
    605656       // Web documents shouldn't contains \x00 symbol
     
    620671       $parser->set_object($this);
    621672
    622        $parser->set_element_handler('_openHandler','_closeHandler');
    623        $parser->set_data_handler('_dataHandler');
    624        $parser->set_escape_handler('_escapeHandler');
     673       $parser->set_element_handler('openHandler', 'closeHandler');
     674       $parser->set_data_handler('dataHandler');
     675       $parser->set_escape_handler('escapeHandler');
    625676
    626677       $parser->parse($doc);
    627678
    628        return $this->getXHTML();
    629 
    630     }
    631 
     679       $result = $this->getXHTML();
     680
     681       $this->clear();
     682
     683       return $result;
     684    }
    632685
    633686    /**
     
    636689     * @param string $str HTML document for recode ASCII part of UTF-7 back to ASCII
    637690     * @return string Decoded document
    638      * @access private
    639      */
    640     function repackUTF7($str)
     691     */
     692    protected function repackUTF7($str)
    641693    {
    642694       return preg_replace_callback('!\+([0-9a-zA-Z/]+)\-!', array($this, 'repackUTF7Callback'), $str);
     
    648700     * @param string $str String for recode ASCII part of UTF-7 back to ASCII
    649701     * @return string Recoded string
    650      * @access private
    651      */
    652     function repackUTF7Callback($str)
     702     */
     703    protected function repackUTF7Callback($str)
    653704    {
    654705       $str = base64_decode($str[1]);
     
    662713     * @param string $str String for recode ASCII part of UTF-7 back to ASCII
    663714     * @return string Recoded string
    664      * @access private
    665      */
    666     function repackUTF7Back($str)
     715     */
     716    protected function repackUTF7Back($str)
    667717    {
    668718       return $str[1].'+'.rtrim(base64_encode($str[2]), '=').'-';
  • _core_/plugins/safehtml/lib/safehtml/license.txt

    r82427 r111709  
     1(c) Miguel Vazquez Gocobachi, WackoWiki Team, 2005-2017
    12(c) Roman Ivanov, 2004-2005
    23(c) Pixel-Apes ( http://pixel-apes.com/ ), 2004-2005
  • _core_/plugins/safehtml/lib/safehtml/readme-SPIP.txt

    r82427 r111709  
    33
    44--------
    5 Version 1.3.7.
    6 http://pixel-apes.com/safehtml/
     5Version 1.3.10.
     6https://bitbucket.org/wackowiki/wackowiki-dev/src/0861d16a01dd/wacko/lib/safehtml/
    77--------
    88
  • _core_/plugins/safehtml/lib/safehtml/readme.txt

    r82427 r111709  
    11SafeHTML
    22--------
    3 Version 1.3.7.
    4 http://pixel-apes.com/safehtml/
     3Version 1.3.10.
     4https://wackowiki.org/doc/Dev/Projects/SafeHTML
    55--------
    66
     
    88  * opening tag without its closing tag
    99  * closing tag without its opening tag
    10   * any of these tags: "base", "basefont", "head", "html", "body", "applet", "object", 
    11     "iframe", "frame", "frameset", "script", "layer", "ilayer", "embed", "bgsound", 
     10  * any of these tags: "base", "basefont", "head", "html", "body", "applet", "object",
     11    "iframe", "frame", "frameset", "script", "layer", "ilayer", "embed", "bgsound",
    1212    "link", "meta", "style", "title", "blink", "xml" etc.
    1313  * any of these attributes: on*, data*, dynsrc
     
    1717It also tries to convert code to XHTML valid, but htmltidy is far better solution for this task.
    1818
    19 If you found any bugs in this parser, please inform me -- ICQ:551593 or mailto:thingol@mail.ru
     19If you found any bugs in this parser, please file an issue -- https://wackowiki.org/bugs/
    2020
    21 Please, subscribe to http://pixel-apes.com/safehtml/feed/rss feed in order to receive notices
     21Please, subscribe to https://wackowiki.org/doc/Dev/Projects/SafeHTML in order to receive notices
    2222when SAFEHTML will be updated.
    2323
     
    3131Version history:
    3232--------
     331.3.10.
     34 * added HTML5 Block-level elements
     351.3.9.
     36 * Replaced preg_replace() e modifier with preg_replace_callback
     371.3.8.
     38 * UTF-7 XSS vulnerability fixed
    33391.3.7.
    3440 * Added 'dl' to the list of 'lists' tags.
  • _core_/plugins/safehtml/paquet.xml

    r106538 r111709  
    22        prefix="safehtml"
    33        categorie="performance"
    4         version="1.6.0"
     4        version="1.6.1"
    55        etat="stable"
    66        compatibilite="[3.3.0-dev;3.3.*]"
Note: See TracChangeset for help on using the changeset viewer.