Sanitizer.php

Go to the documentation of this file.

<?php
 
 
namespace enshrined\svgSanitize;
 
 
use DOMDocument;
use enshrined\svgSanitize\data\AllowedAttributes;
use enshrined\svgSanitize\data\AllowedTags;
use enshrined\svgSanitize\data\AttributeInterface;
use enshrined\svgSanitize\data\TagInterface;
 
class Sanitizer
{
 
    const SCRIPT_REGEX = '/(?:\w+script|data):/xi';
 
    const REMOTE_REFERENCE_REGEX = '/url\‍(([\'"]?(?:http|https):)[\'"]?([^\'"\‍)]*)[\'"]?\‍)/xi';
 
    protected $xmlDocument;
 
    protected $allowedTags;
 
    protected $allowedAttrs;
 
    protected $xmlLoaderValue;
 
    protected $minifyXML = false;
 
    protected $removeRemoteReferences = false;
 
    function __construct()
    {
        $this->resetInternal();
 
        // Load default tags/attributes
        $this->allowedAttrs = AllowedAttributes::getAttributes();
        $this->allowedTags = AllowedTags::getTags();
    }
 
    protected function resetInternal()
    {
        $this->xmlDocument = new DOMDocument();
        $this->xmlDocument->preserveWhiteSpace = false;
        $this->xmlDocument->strictErrorChecking = false;
        $this->xmlDocument->formatOutput = true;
 
        // Maybe don't format the output
        if($this->minifyXML) {
            $this->xmlDocument->formatOutput = false;
        }
    }
 
    public function getAllowedTags()
    {
        return $this->allowedTags;
    }
 
    public function setAllowedTags(TagInterface $allowedTags)
    {
        $this->allowedTags = $allowedTags::getTags();
    }
 
    public function getAllowedAttrs()
    {
        return $this->allowedAttrs;
    }
 
    public function setAllowedAttrs(AttributeInterface $allowedAttrs)
    {
        $this->allowedAttrs = $allowedAttrs::getAttributes();
    }
 
    public function removeRemoteReferences($removeRemoteRefs = false)
    {
        $this->removeRemoteReferences = $removeRemoteRefs;
    }
 
    public function sanitize($dirty)
    {
        // Don't run on an empty string
        if (empty($dirty)) {
            return '';
        }
 
        // Strip php tags
        $dirty = preg_replace('/<\?(=|php)(.+?)\?>/i', '', $dirty);
 
        $this->setUpBefore();
 
        $loaded = $this->xmlDocument->loadXML($dirty);
 
        // If we couldn't parse the XML then we go no further. Reset and return false
        if (!$loaded) {
            $this->resetAfter();
            return false;
        }
 
        $this->removeDoctype();
 
        // Grab all the elements
        $allElements = $this->xmlDocument->getElementsByTagName("*");
 
        // Start the cleaning proccess
        $this->startClean($allElements);
 
        // Save cleaned XML to a variable
        $clean = $this->xmlDocument->saveXML($this->xmlDocument->documentElement, LIBXML_NOEMPTYTAG);
 
        $this->resetAfter();
 
        // Remove any extra whitespaces when minifying
        if($this->minifyXML) {
            $clean = preg_replace('/\s+/', ' ', $clean);
        }
 
        // Return result
        return $clean;
    }
 
    protected function setUpBefore()
    {
        // Turn off the entity loader
        $this->xmlLoaderValue = libxml_disable_entity_loader(true);
 
        // Suppress the errors because we don't really have to worry about formation before cleansing
        libxml_use_internal_errors(true);
    }
 
    protected function resetAfter()
    {
        // Reset DOMDocument to a clean state in case we use it again
        $this->resetInternal();
 
        // Reset the entity loader3
        libxml_disable_entity_loader($this->xmlLoaderValue);
    }
 
    protected function removeDoctype()
    {
        foreach ($this->xmlDocument->childNodes as $child) {
            if ($child->nodeType === XML_DOCUMENT_TYPE_NODE) {
                $child->parentNode->removeChild($child);
            }
        }
    }
 
    protected function startClean(\DOMNodeList $elements)
    {
        // loop through all elements
        // we do this backwards so we don't skip anything if we delete a node
        // see comments at: http://php.net/manual/en/class.domnamednodemap.php
        for ($i = $elements->length - 1; $i >= 0; $i--) {
            $currentElement = $elements->item($i);
 
            // If the tag isn't in the whitelist, remove it and continue with next iteration
            if (!in_array(strtolower($currentElement->tagName), $this->allowedTags)) {
                $currentElement->parentNode->removeChild($currentElement);
                continue;
            }
 
            $this->cleanAttributesOnWhitelist($currentElement);
 
            $this->cleanXlinkHrefs($currentElement);
 
            $this->cleanHrefs($currentElement);
        }
    }
 
    protected function cleanAttributesOnWhitelist(\DOMElement $element)
    {
        for ($x = $element->attributes->length - 1; $x >= 0; $x--) {
            // get attribute name
            $attrName = $element->attributes->item($x)->name;
 
            // Remove attribute if not in whitelist
            if (!in_array(strtolower($attrName), $this->allowedAttrs)) {
                $element->removeAttribute($attrName);
            }
 
            // Do we want to strip remote references?
            if($this->removeRemoteReferences) {
                // Remove attribute if it has a remote reference
                if (isset($element->attributes->item($x)->value) && $this->hasRemoteReference($element->attributes->item($x)->value)) {
                    $element->removeAttribute($attrName);
                }
            }
        }
    }
 
    protected function cleanXlinkHrefs(\DOMElement &$element)
    {
        $xlinks = $element->getAttributeNS('http://www.w3.org/1999/xlink', 'href');
        if (preg_match(self::SCRIPT_REGEX, $xlinks) === 1) {
            $element->removeAttributeNS('http://www.w3.org/1999/xlink', 'href');
        }
    }
 
    protected function cleanHrefs(\DOMElement &$element)
    {
        $href = $element->getAttribute('href');
        if (preg_match(self::SCRIPT_REGEX, $href) === 1) {
            $element->removeAttribute('href');
        }
    }
 
    protected function hasRemoteReference($value)
    {
        if (preg_match(self::REMOTE_REFERENCE_REGEX, $value) === 1) {
            return true;
        }
 
        return false;
    }
 
    public function minify($shouldMinify = false)
    {
        $this->minifyXML = (bool) $shouldMinify;
    }
}