include/phpmailer/extras/htmlfilter.php
<?php
/**
* htmlfilter.inc
* ---------------
* This set of functions allows you to filter html in order to remove
* any malicious tags from it. Useful in cases when you need to filter
* user input for any cross-site-scripting attempts.
*
* Copyright (C) 2002-2004 by Duke University
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
* @Author Konstantin Riabitsev <icon@linux.duke.edu>
* @Author Jim Jagielski <jim@jaguNET.com / jimjag@gmail.com>
* @Version 1.1 ($Date$)
* @param mixed $tagname
* @param mixed $attary
* @param mixed $tagtype
*/
/**
* This function returns the final tag out of the tag name, an array
* of attributes, and the type of the tag. This function is called by
* tln_sanitize internally.
*
* @param string $tagname the name of the tag.
* @param array $attary the array of attributes and their values
* @param int $tagtype The type of the tag (see in comments).
* @return string A string with the final tag representation.
*/
function tln_tagprint($tagname, $attary, $tagtype)
{
if (2 == $tagtype) {
$fulltag = '</' . $tagname . '>';
} else {
$fulltag = '<' . $tagname;
if (is_array($attary) && count($attary)) {
$atts = [];
foreach ($attary as $attname => $attvalue) {
array_push($atts, "$attname=$attvalue");
}
$fulltag .= ' ' . implode(' ', $atts);
}
if (3 == $tagtype) {
$fulltag .= ' /';
}
$fulltag .= '>';
}
return $fulltag;
}
/**
* A small helper function to use with array_walk. Modifies a by-ref
* value and makes it lowercase.
*
* @param string $val a value passed by-ref.
*/
function tln_casenormalize(&$val)
{
$val = mb_strtolower($val);
}
/**
* This function skips any whitespace from the current position within
* a string and to the next non-whitespace value.
*
* @param string $body the string
* @param int $offset the offset within the string where we should start
* looking for the next non-whitespace character.
* @return int the location within the $body where the next
* non-whitespace char is located.
*/
function tln_skipspace($body, $offset)
{
preg_match('/^(\s*)/s', mb_substr($body, $offset), $matches);
if (count($matches[1])) {
$count = mb_strlen($matches[1]);
$offset += $count;
}
return $offset;
}
/**
* This function looks for the next character within a string. It's
* really just a glorified "strpos", except it catches the failures
* nicely.
*
* @param string $body The string to look for needle in.
* @param int $offset Start looking from this position.
* @param string $needle The character/string to look for.
* @return int location of the next occurrence of the needle, or
* strlen($body) if needle wasn't found.
*/
function tln_findnxstr($body, $offset, $needle)
{
$pos = mb_strpos($body, $needle, $offset);
if (false === $pos) {
$pos = mb_strlen($body);
}
return $pos;
}
/**
* This function takes a PCRE-style regexp and tries to match it
* within the string.
*
* @param string $body The string to look for needle in.
* @param int $offset Start looking from here.
* @param string $reg A PCRE-style regex to match.
* @return array|bool Returns a false if no matches found, or an array
* with the following members:
* - integer with the location of the match within $body
* - string with whatever content between offset and the match
* - string with whatever it is we matched
*/
function tln_findnxreg($body, $offset, $reg)
{
$matches = [];
$retarr = [];
$preg_rule = '%^(.*?)(' . $reg . ')%s';
preg_match($preg_rule, mb_substr($body, $offset), $matches);
if (!isset($matches[0]) || !$matches[0]) {
$retarr = false;
} else {
$retarr[0] = $offset + mb_strlen($matches[1]);
$retarr[1] = $matches[1];
$retarr[2] = $matches[2];
}
return $retarr;
}
/**
* This function looks for the next tag.
*
* @param string $body String where to look for the next tag.
* @param int $offset Start looking from here.
* @return array|bool false if no more tags exist in the body, or
* an array with the following members:
* - string with the name of the tag
* - array with attributes and their values
* - integer with tag type (1, 2, or 3)
* - integer where the tag starts (starting "<")
* - integer where the tag ends (ending ">")
* first three members will be false, if the tag is invalid.
*/
function tln_getnxtag($body, $offset)
{
if ($offset > mb_strlen($body)) {
return false;
}
$lt = tln_findnxstr($body, $offset, '<');
if ($lt == mb_strlen($body)) {
return false;
}
/**
* We are here:
* blah blah <tag attribute="value">
* \---------^
*/
$pos = tln_skipspace($body, $lt + 1);
if ($pos >= mb_strlen($body)) {
return [false, false, false, $lt, mb_strlen($body)];
}
/**
* There are 3 kinds of tags:
* 1. Opening tag, e.g.:
* <a href="blah">
* 2. Closing tag, e.g.:
* </a>
* 3. XHTML-style content-less tag, e.g.:
* <img src="blah"/>
*/
switch (mb_substr($body, $pos, 1)) {
case '/':
$tagtype = 2;
$pos++;
break;
case '!':
/**
* A comment or an SGML declaration.
*/
if ('--' == mb_substr($body, $pos + 1, 2)) {
$gt = mb_strpos($body, '-->', $pos);
if (false === $gt) {
$gt = mb_strlen($body);
} else {
$gt += 2;
}
return [false, false, false, $lt, $gt];
}
$gt = tln_findnxstr($body, $pos, '>');
return [false, false, false, $lt, $gt];
break;
default:
/**
* Assume tagtype 1 for now. If it's type 3, we'll switch values
* later.
*/
$tagtype = 1;
break;
}
/**
* Look for next [\W-_], which will indicate the end of the tag name.
*/
$regary = tln_findnxreg($body, $pos, '[^\w\-_]');
if (false == $regary) {
return [false, false, false, $lt, mb_strlen($body)];
}
list($pos, $tagname, $match) = $regary;
$tagname = mb_strtolower($tagname);
/**
* $match can be either of these:
* '>' indicating the end of the tag entirely.
* '\s' indicating the end of the tag name.
* '/' indicating that this is type-3 xhtml tag.
*
* Whatever else we find there indicates an invalid tag.
*/
switch ($match) {
case '/':
/**
* This is an xhtml-style tag with a closing / at the
* end, like so: <img src="blah"/>. Check if it's followed
* by the closing bracket. If not, then this tag is invalid
*/
if ('/>' == mb_substr($body, $pos, 2)) {
$pos++;
$tagtype = 3;
} else {
$gt = tln_findnxstr($body, $pos, '>');
$retary = [false, false, false, $lt, $gt];
return $retary;
}
//intentional fall-through
// no break
case '>':
return [$tagname, false, $tagtype, $lt, $pos];
break;
default:
/**
* Check if it's whitespace
*/
if (!preg_match('/\s/', $match)) {
/**
* This is an invalid tag! Look for the next closing ">".
*/
$gt = tln_findnxstr($body, $lt, '>');
return [false, false, false, $lt, $gt];
}
break;
}
/**
* At this point we're here:
* <tagname attribute='blah'>
* \-------^
*
* At this point we loop in order to find all attributes.
*/
$attary = [];
while ($pos <= mb_strlen($body)) {
$pos = tln_skipspace($body, $pos);
if ($pos == mb_strlen($body)) {
/**
* Non-closed tag.
*/
return [false, false, false, $lt, $pos];
}
/**
* See if we arrived at a ">" or "/>", which means that we reached
* the end of the tag.
*/
$matches = [];
if (preg_match('%^(\s*)(>|/>)%s', mb_substr($body, $pos), $matches)) {
/**
* Yep. So we did.
*/
$pos += mb_strlen($matches[1]);
if ('/>' == $matches[2]) {
$tagtype = 3;
$pos++;
}
return [$tagname, $attary, $tagtype, $lt, $pos];
}
/**
* There are several types of attributes, with optional
* [:space:] between members.
* Type 1:
* attrname[:space:]=[:space:]'CDATA'
* Type 2:
* attrname[:space:]=[:space:]"CDATA"
* Type 3:
* attr[:space:]=[:space:]CDATA
* Type 4:
* attrname
*
* We leave types 1 and 2 the same, type 3 we check for
* '"' and convert to """ if needed, then wrap in
* double quotes. Type 4 we convert into:
* attrname="yes".
*/
$regary = tln_findnxreg($body, $pos, '[^\w\-_]');
if (false == $regary) {
/**
* Looks like body ended before the end of tag.
*/
return [false, false, false, $lt, mb_strlen($body)];
}
list($pos, $attname, $match) = $regary;
$attname = mb_strtolower($attname);
/**
* We arrived at the end of attribute name. Several things possible
* here:
* '>' means the end of the tag and this is attribute type 4
* '/' if followed by '>' means the same thing as above
* '\s' means a lot of things -- look what it's followed by.
* anything else means the attribute is invalid.
*/
switch ($match) {
case '/':
/**
* This is an xhtml-style tag with a closing / at the
* end, like so: <img src="blah"/>. Check if it's followed
* by the closing bracket. If not, then this tag is invalid
*/
if ('/>' == mb_substr($body, $pos, 2)) {
$pos++;
$tagtype = 3;
} else {
$gt = tln_findnxstr($body, $pos, '>');
$retary = [false, false, false, $lt, $gt];
return $retary;
}
//intentional fall-through
// no break
case '>':
$attary[$attname] = '"yes"';
return [$tagname, $attary, $tagtype, $lt, $pos];
break;
default:
/**
* Skip whitespace and see what we arrive at.
*/
$pos = tln_skipspace($body, $pos);
$char = mb_substr($body, $pos, 1);
/**
* Two things are valid here:
* '=' means this is attribute type 1 2 or 3.
* \w means this was attribute type 4.
* anything else we ignore and re-loop. End of tag and
* invalid stuff will be caught by our checks at the beginning
* of the loop.
*/
if ('=' == $char) {
$pos++;
$pos = tln_skipspace($body, $pos);
/**
* Here are 3 possibilities:
* "'" attribute type 1
* '"' attribute type 2
* everything else is the content of tag type 3
*/
$quot = mb_substr($body, $pos, 1);
if ('\'' == $quot) {
$regary = tln_findnxreg($body, $pos + 1, '\'');
if (false == $regary) {
return [false, false, false, $lt, mb_strlen($body)];
}
list($pos, $attval, $match) = $regary;
$pos++;
$attary[$attname] = '\'' . $attval . '\'';
} elseif ('"' == $quot) {
$regary = tln_findnxreg($body, $pos + 1, '\"');
if (false == $regary) {
return [false, false, false, $lt, mb_strlen($body)];
}
list($pos, $attval, $match) = $regary;
$pos++;
$attary[$attname] = '"' . $attval . '"';
} else {
/**
* These are hateful. Look for \s, or >.
*/
$regary = tln_findnxreg($body, $pos, '[\s>]');
if (false == $regary) {
return [false, false, false, $lt, mb_strlen($body)];
}
list($pos, $attval, $match) = $regary;
/**
* If it's ">" it will be caught at the top.
*/
$attval = preg_replace('/\"/s', '"', $attval);
$attary[$attname] = '"' . $attval . '"';
}
} elseif (preg_match('|[\w/>]|', $char)) {
/**
* That was attribute type 4.
*/
$attary[$attname] = '"yes"';
} else {
/**
* An illegal character. Find next '>' and return.
*/
$gt = tln_findnxstr($body, $pos, '>');
return [false, false, false, $lt, $gt];
}
break;
}
}
/**
* The fact that we got here indicates that the tag end was never
* found. Return invalid tag indication so it gets stripped.
*/
return [false, false, false, $lt, mb_strlen($body)];
}
/**
* Translates entities into literal values so they can be checked.
*
* @param string $attvalue the by-ref value to check.
* @param string $regex the regular expression to check against.
* @param bool $hex whether the entities are hexadecimal.
* @return bool True or False depending on whether there were matches.
*/
function tln_deent(&$attvalue, $regex, $hex = false)
{
preg_match_all($regex, $attvalue, $matches);
if (is_array($matches) && count($matches[0]) > 0) {
$repl = [];
for ($i = 0; $i < count($matches[0]); $i++) {
$numval = $matches[1][$i];
if ($hex) {
$numval = hexdec($numval);
}
$repl[$matches[0][$i]] = chr($numval);
}
$attvalue = strtr($attvalue, $repl);
return true;
}
return false;
}
/**
* This function checks attribute values for entity-encoded values
* and returns them translated into 8-bit strings so we can run
* checks on them.
*
* @param string $attvalue A string to run entity check against.
*/
function tln_defang(&$attvalue)
{
/**
* Skip this if there aren't ampersands or backslashes.
*/
if (false === mb_strpos($attvalue, '&')
&& false === mb_strpos($attvalue, '\\')) {
return;
}
do {
$m = false;
$m = $m || tln_deent($attvalue, '/\�*(\d+);*/s');
$m = $m || tln_deent($attvalue, '/\�*((\d|[a-f])+);*/si', true);
$m = $m || tln_deent($attvalue, '/\\\\(\d+)/s', true);
} while (true == $m);
$attvalue = stripslashes($attvalue);
}
/**
* Kill any tabs, newlines, or carriage returns. Our friends the
* makers of the browser with 95% market value decided that it'd
* be funny to make "java[tab]script" be just as good as "javascript".
*
* @param string $attvalue The attribute value before extraneous spaces removed.
*/
function tln_unspace(&$attvalue)
{
if (strcspn($attvalue, "\t\r\n\0 ") != mb_strlen($attvalue)) {
$attvalue = str_replace(["\t", "\r", "\n", "\0", ' '], ['', '', '', '', ''], $attvalue);
}
}
/**
* This function runs various checks against the attributes.
*
* @param string $tagname String with the name of the tag.
* @param array $attary Array with all tag attributes.
* @param array $rm_attnames See description for tln_sanitize
* @param array $bad_attvals See description for tln_sanitize
* @param array $add_attr_to_tag See description for tln_sanitize
* @param string $trans_image_path
* @param bool $block_external_images
* @return array with modified attributes.
*/
function tln_fixatts(
$tagname,
$attary,
$rm_attnames,
$bad_attvals,
$add_attr_to_tag,
$trans_image_path,
$block_external_images)
{
foreach ($attary as $attname => $attvalue) {
/**
* See if this attribute should be removed.
*/
foreach ($rm_attnames as $matchtag => $matchattrs) {
if (preg_match($matchtag, $tagname)) {
foreach ($matchattrs as $matchattr) {
if (preg_match($matchattr, $attname)) {
unset($attary[$attname]);
continue;
}
}
}
}
/**
* Remove any backslashes, entities, or extraneous whitespace.
*/
$oldattvalue = $attvalue;
tln_defang($attvalue);
if ('style' == $attname && $attvalue !== $oldattvalue) {
$attvalue = 'idiocy';
$attary[$attname] = $attvalue;
}
tln_unspace($attvalue);
/**
* Now let's run checks on the attvalues.
* I don't expect anyone to comprehend this. If you do,
* get in touch with me so I can drive to where you live and
* shake your hand personally. :)
*/
foreach ($bad_attvals as $matchtag => $matchattrs) {
if (preg_match($matchtag, $tagname)) {
foreach ($matchattrs as $matchattr => $valary) {
if (preg_match($matchattr, $attname)) {
/**
* There are two arrays in valary.
* First is matches.
* Second one is replacements
*/
list($valmatch, $valrepl) = $valary;
$newvalue = preg_replace($valmatch, $valrepl, $attvalue);
if ($newvalue != $attvalue) {
$attary[$attname] = $newvalue;
$attvalue = $newvalue;
}
}
}
}
}
if ('style' == $attname) {
if (preg_match('/[\0-\37\200-\377]+/', $attvalue)) {
$attary[$attname] = '"disallowed character"';
}
preg_match_all("/url\s*\((.+)\)/si", $attvalue, $aMatch);
if (count($aMatch)) {
foreach ($aMatch[1] as $sMatch) {
$urlvalue = $sMatch;
tln_fixurl($attname, $urlvalue, $trans_image_path, $block_external_images);
$attary[$attname] = str_replace($sMatch, $urlvalue, $attvalue);
}
}
}
}
/**
* See if we need to append any attributes to this tag.
*/
foreach ($add_attr_to_tag as $matchtag => $addattary) {
if (preg_match($matchtag, $tagname)) {
$attary = array_merge($attary, $addattary);
}
}
return $attary;
}
function tln_fixurl($attname, &$attvalue, $trans_image_path, $block_external_images)
{
$sQuote = '"';
$attvalue = trim($attvalue);
if ($attvalue && ('"' == $attvalue[0] || "'" == $attvalue[0])) {
// remove the double quotes
$sQuote = $attvalue[0];
$attvalue = trim(mb_substr($attvalue, 1, -1));
}
/**
* Replace empty src tags with the blank image. src is only used
* for frames, images, and image inputs. Doing a replace should
* not affect them working as should be, however it will stop
* IE from being kicked off when src for img tags are not set
*/
if ('' == $attvalue) {
$attvalue = $sQuote . $trans_image_path . $sQuote;
} else {
// first, disallow 8 bit characters and control characters
if (preg_match('/[\0-\37\200-\377]+/', $attvalue)) {
switch ($attname) {
case 'href':
$attvalue = $sQuote . 'http://invalid-stuff-detected.example.com' . $sQuote;
break;
default:
$attvalue = $sQuote . $trans_image_path . $sQuote;
break;
}
} else {
$aUrl = parse_url($attvalue);
if (isset($aUrl['scheme'])) {
switch (mb_strtolower($aUrl['scheme'])) {
case 'mailto':
case 'http':
case 'https':
case 'ftp':
if ('href' != $attname) {
if (true == $block_external_images) {
$attvalue = $sQuote . $trans_image_path . $sQuote;
} else {
if (!isset($aUrl['path'])) {
$attvalue = $sQuote . $trans_image_path . $sQuote;
}
}
} else {
$attvalue = $sQuote . $attvalue . $sQuote;
}
break;
case 'outbind':
$attvalue = $sQuote . $attvalue . $sQuote;
break;
case 'cid':
$attvalue = $sQuote . $attvalue . $sQuote;
break;
default:
$attvalue = $sQuote . $trans_image_path . $sQuote;
break;
}
} else {
if (!isset($aUrl['path']) || $aUrl['path'] != $trans_image_path) {
$$attvalue = $sQuote . $trans_image_path . $sQuote;
}
}
}
}
}
/**
* @param string $body
* @param int $pos
* @param string $trans_image_path
* @param bool $block_external_images
*/
function tln_fixstyle($body, $pos, $trans_image_path, $block_external_images)
{
// workaround for </style> in between comments
$content = '';
$sToken = '';
$bSucces = false;
$bEndTag = false;
for ($i = $pos, $iCount = mb_strlen($body); $i < $iCount; ++$i) {
$char = $body[$i];
switch ($char) {
case '<':
$sToken = $char;
break;
case '/':
if ('<' == $sToken) {
$sToken .= $char;
$bEndTag = true;
} else {
$content .= $char;
}
break;
case '>':
if ($bEndTag) {
$sToken .= $char;
if (preg_match('/\<\/\s*style\s*\>/i', $sToken, $aMatch)) {
$newpos = $i + 1;
$bSucces = true;
break 2;
}
$content .= $sToken;
$bEndTag = false;
} else {
$content .= $char;
}
break;
case '!':
if ('<' == $sToken) {
// possible comment
if (isset($body[$i + 2]) && '!--' == mb_substr($body, $i, 3)) {
$i = mb_strpos($body, '-->', $i + 3);
if (false === $i) { // no end comment
$i = mb_strlen($body);
}
$sToken = '';
}
} else {
$content .= $char;
}
break;
default:
if ($bEndTag) {
$sToken .= $char;
} else {
$content .= $char;
}
break;
}
}
if (false == $bSucces) {
return [false, mb_strlen($body)];
}
/**
* First look for general BODY style declaration, which would be
* like so:
* body {background: blah-blah}
* and change it to .bodyclass so we can just assign it to a <div>
*/
$content = preg_replace("|body(\s*\{.*?\})|si", '.bodyclass\\1', $content);
/**
* Fix url('blah') declarations.
*/
// $content = preg_replace("|url\s*\(\s*([\'\"])\s*\S+script\s*:.*?([\'\"])\s*\)|si",
// "url(\\1$trans_image_path\\2)", $content);
// first check for 8bit sequences and disallowed control characters
if (preg_match('/[\16-\37\200-\377]+/', $content)) {
$content = '<!-- style block removed by html filter due to presence of 8bit characters -->';
return [$content, $newpos];
}
// remove @import line
$content = preg_replace("/^\s*(@import.*)$/mi", "\n<!-- @import rules forbidden -->\n", $content);
$content = preg_replace('/(\\\\)?u(\\\\)?r(\\\\)?l(\\\\)?/i', 'url', $content);
preg_match_all("/url\s*\((.+)\)/si", $content, $aMatch);
if (count($aMatch)) {
$aValue = $aReplace = [];
foreach ($aMatch[1] as $sMatch) {
// url value
$urlvalue = $sMatch;
tln_fixurl('style', $urlvalue, $trans_image_path, $block_external_images);
$aValue[] = $sMatch;
$aReplace[] = $urlvalue;
}
$content = str_replace($aValue, $aReplace, $content);
}
/**
* Remove any backslashes, entities, and extraneous whitespace.
*/
$contentTemp = $content;
tln_defang($contentTemp);
tln_unspace($contentTemp);
$match = [
'/\/\*.*\*\//',
'/expression/i',
'/behaviou*r/i',
'/binding/i',
'/include-source/i',
'/javascript/i',
'/script/i',
'/position/i',
];
$replace = ['', 'idiocy', 'idiocy', 'idiocy', 'idiocy', 'idiocy', 'idiocy', ''];
$contentNew = preg_replace($match, $replace, $contentTemp);
if ($contentNew !== $contentTemp) {
$content = $contentNew;
}
return [$content, $newpos];
}
/**
* @param string $trans_image_path
*/
function tln_body2div($attary, $trans_image_path)
{
$divattary = ['class' => "'bodyclass'"];
$text = '#000000';
$has_bgc_stl = $has_txt_stl = false;
$styledef = '';
if (is_array($attary) && count($attary) > 0) {
foreach ($attary as $attname => $attvalue) {
$quotchar = mb_substr($attvalue, 0, 1);
$attvalue = str_replace($quotchar, '', $attvalue);
switch ($attname) {
case 'background':
$styledef .= "background-image: url('$trans_image_path'); ";
break;
case 'bgcolor':
$has_bgc_stl = true;
$styledef .= "background-color: $attvalue; ";
break;
case 'text':
$has_txt_stl = true;
$styledef .= "color: $attvalue; ";
break;
}
}
// Outlook defines a white bgcolor and no text color. This can lead to
// white text on a white bg with certain themes.
if ($has_bgc_stl && !$has_txt_stl) {
$styledef .= "color: $text; ";
}
if (mb_strlen($styledef) > 0) {
$divattary['style'] = "\"$styledef\"";
}
}
return $divattary;
}
/**
* @param string $body The HTML you wish to filter
* @param array $tag_list see description above
* @param string[] $rm_tags_with_content see description above
* @param string[] $self_closing_tags see description above
* @param bool $force_tag_closing see description above
* @param array $rm_attnames see description above
* @param array $bad_attvals see description above
* @param array $add_attr_to_tag see description above
* @param string $trans_image_path
* @param bool $block_external_images
* @return string Sanitized html safe to show on your pages.
*/
function tln_sanitize(
$body,
$tag_list,
$rm_tags_with_content,
$self_closing_tags,
$force_tag_closing,
$rm_attnames,
$bad_attvals,
$add_attr_to_tag,
$trans_image_path,
$block_external_images)
{
/**
* Normalize rm_tags and rm_tags_with_content.
*/
$rm_tags = array_shift($tag_list);
@array_walk($tag_list, 'tln_casenormalize');
@array_walk($rm_tags_with_content, 'tln_casenormalize');
@array_walk($self_closing_tags, 'tln_casenormalize');
/**
* See if tag_list is of tags to remove or tags to allow.
* false means remove these tags
* true means allow these tags
*/
$curpos = 0;
$open_tags = [];
$trusted = "<!-- begin tln_sanitized html -->\n";
$skip_content = false;
/**
* Take care of netscape's stupid javascript entities like
* &{alert('boo')};
*/
$body = preg_replace('/&(\{.*?\};)/si', '&\\1', $body);
while (false != ($curtag = tln_getnxtag($body, $curpos))) {
list($tagname, $attary, $tagtype, $lt, $gt) = $curtag;
$free_content = mb_substr($body, $curpos, $lt - $curpos);
/**
* Take care of <style>
*/
if ('style' == $tagname && 1 == $tagtype) {
list($free_content, $curpos) = tln_fixstyle($body, $gt + 1, $trans_image_path, $block_external_images);
if (false != $free_content) {
if (!empty($attary)) {
$attary = tln_fixatts($tagname, $attary, $rm_attnames, $bad_attvals, $add_attr_to_tag, $trans_image_path, $block_external_images);
}
$trusted .= tln_tagprint($tagname, $attary, $tagtype);
$trusted .= $free_content;
$trusted .= tln_tagprint($tagname, null, 2);
}
continue;
}
if (false == $skip_content) {
$trusted .= $free_content;
}
if (false != $tagname) {
if (2 == $tagtype) {
if ($skip_content == $tagname) {
/**
* Got to the end of tag we needed to remove.
*/
$tagname = false;
$skip_content = false;
} else {
if (false == $skip_content) {
if ('body' == $tagname) {
$tagname = 'div';
}
if (isset($open_tags[$tagname])
&& $open_tags[$tagname] > 0) {
$open_tags[$tagname]--;
} else {
$tagname = false;
}
}
}
} else {
/**
* $rm_tags_with_content
*/
if (false == $skip_content) {
/**
* See if this is a self-closing type and change
* tagtype appropriately.
*/
if (1 == $tagtype
&& in_array($tagname, $self_closing_tags, true)) {
$tagtype = 3;
}
/**
* See if we should skip this tag and any content
* inside it.
*/
if (1 == $tagtype
&& in_array($tagname, $rm_tags_with_content, true)) {
$skip_content = $tagname;
} else {
if ((false == $rm_tags
&& in_array($tagname, $tag_list, true))
|| (true == $rm_tags
&& !in_array($tagname, $tag_list, true))) {
$tagname = false;
} else {
/**
* Convert body into div.
*/
if ('body' == $tagname) {
$tagname = 'div';
$attary = tln_body2div($attary, $trans_image_path);
}
if (1 == $tagtype) {
if (isset($open_tags[$tagname])) {
$open_tags[$tagname]++;
} else {
$open_tags[$tagname] = 1;
}
}
/**
* This is where we run other checks.
*/
if (is_array($attary) && count($attary) > 0) {
$attary = tln_fixatts($tagname, $attary, $rm_attnames, $bad_attvals, $add_attr_to_tag, $trans_image_path, $block_external_images);
}
}
}
}
}
if (false != $tagname && false == $skip_content) {
$trusted .= tln_tagprint($tagname, $attary, $tagtype);
}
}
$curpos = $gt + 1;
}
$trusted .= mb_substr($body, $curpos, mb_strlen($body) - $curpos);
if (true == $force_tag_closing) {
foreach ($open_tags as $tagname => $opentimes) {
while ($opentimes > 0) {
$trusted .= '</' . $tagname . '>';
$opentimes--;
}
}
$trusted .= "\n";
}
$trusted .= "<!-- end tln_sanitized html -->\n";
return $trusted;
}
//
// Use the nifty htmlfilter library
//
function HTMLFilter($body, $trans_image_path, $block_external_images = false)
{
$tag_list = [
false,
'object',
'meta',
'html',
'head',
'base',
'link',
'frame',
'iframe',
'plaintext',
'marquee',
];
$rm_tags_with_content = [
'script',
'applet',
'embed',
'title',
'frameset',
'xmp',
'xml',
];
$self_closing_tags = [
'img',
'br',
'hr',
'input',
'outbind',
];
$force_tag_closing = true;
$rm_attnames = [
'/.*/' => [
// "/target/i",
'/^on.*/i',
'/^dynsrc/i',
'/^data.*/i',
'/^lowsrc.*/i',
],
];
$bad_attvals = [
'/.*/' => [
'/^src|background/i' => [
[
'/^([\'"])\s*\S+script\s*:.*([\'"])/si',
'/^([\'"])\s*mocha\s*:*.*([\'"])/si',
'/^([\'"])\s*about\s*:.*([\'"])/si',
],
[
"\\1$trans_image_path\\2",
"\\1$trans_image_path\\2",
"\\1$trans_image_path\\2",
],
],
'/^href|action/i' => [
[
'/^([\'"])\s*\S+script\s*:.*([\'"])/si',
'/^([\'"])\s*mocha\s*:*.*([\'"])/si',
'/^([\'"])\s*about\s*:.*([\'"])/si',
],
[
'\\1#\\1',
'\\1#\\1',
'\\1#\\1',
],
],
'/^style/i' => [
[
"/\/\*.*\*\//",
'/expression/i',
'/binding/i',
'/behaviou*r/i',
'/include-source/i',
'/position\s*:/i',
'/(\\\\)?u(\\\\)?r(\\\\)?l(\\\\)?/i',
'/url\s*\(\s*([\'"])\s*\S+script\s*:.*([\'"])\s*\)/si',
'/url\s*\(\s*([\'"])\s*mocha\s*:.*([\'"])\s*\)/si',
'/url\s*\(\s*([\'"])\s*about\s*:.*([\'"])\s*\)/si',
'/(.*)\s*:\s*url\s*\(\s*([\'"]*)\s*\S+script\s*:.*([\'"]*)\s*\)/si',
],
[
'',
'idiocy',
'idiocy',
'idiocy',
'idiocy',
'idiocy',
'url',
'url(\\1#\\1)',
'url(\\1#\\1)',
'url(\\1#\\1)',
'\\1:url(\\2#\\3)',
],
],
],
];
if ($block_external_images) {
array_push($bad_attvals['/.*/']['/^src|background/i'][0], '/^([\'\"])\s*https*:.*([\'\"])/si');
array_push($bad_attvals['/.*/']['/^src|background/i'][1], "\\1$trans_image_path\\1");
array_push($bad_attvals['/.*/']['/^style/i'][0], '/url\(([\'\"])\s*https*:.*([\'\"])\)/si');
array_push($bad_attvals['/.*/']['/^style/i'][1], "url(\\1$trans_image_path\\1)");
}
$add_attr_to_tag = [
'/^a$/i' => ['target' => '"_blank"'],
];
$trusted = tln_sanitize($body, $tag_list, $rm_tags_with_content, $self_closing_tags, $force_tag_closing, $rm_attnames, $bad_attvals, $add_attr_to_tag, $trans_image_path, $block_external_images);
return $trusted;
}