vendor/heimrichhannot/contao-request-bundle/src/Component/HttpFoundation/Request.php line 43

Open in your IDE?
  1. <?php
  3. /*
  4.  * Copyright (c) 2021 Heimrich & Hannot GmbH
  5.  *
  6.  * @license LGPL-3.0-or-later
  7.  */
  9. namespace HeimrichHannot\RequestBundle\Component\HttpFoundation;
  11. use Contao\CoreBundle\Framework\ContaoFrameworkInterface;
  12. use Contao\CoreBundle\Routing\ScopeMatcher;
  13. use Contao\Input;
  14. use Contao\StringUtil;
  15. use Contao\Validator;
  16. use Symfony\Component\CssSelector\Exception\SyntaxErrorException;
  17. use Symfony\Component\HttpFoundation\ParameterBag;
  18. use Symfony\Component\HttpFoundation\RequestStack;
  19. use Wa72\HtmlPageDom\HtmlPageCrawler;
  21. class Request extends \Symfony\Component\HttpFoundation\Request
  22. {
  23.     /**
  24.      * Query string parameters ($_GET).
  25.      *
  26.      * @var QueryParameterBag
  27.      */
  28.     public $query;
  30.     /**
  31.      * @var ContaoFrameworkInterface
  32.      */
  33.     protected $framework;
  35.     /**
  36.      * @var ScopeMatcher
  37.      */
  38.     protected $scopeMatcher;
  40.     /**
  41.      * Request constructor.
  42.      */
  43.     public function __construct(ContaoFrameworkInterface $framework, RequestStack $requestStack, ScopeMatcher $scopeMatcher)
  44.     {
  45.         $this->framework = $framework;
  46.         $this->scopeMatcher = $scopeMatcher;
  48.         $request = $requestStack->getCurrentRequest();
  50.         if (null === $request) {
  51.             parent::__construct([], [], [], [], [], [], null);
  52.         } else {
  53.             parent::__construct(
  54.                 $this->checkCurrentRequest($request->query),
  55.                 $this->checkCurrentRequest($request->request),
  56.                 $this->checkCurrentRequest($request->attributes),
  57.                 $this->checkCurrentRequest($request->cookies),
  58.                 $this->checkCurrentRequest($request->files),
  59.                 $this->checkCurrentRequest($request->server),
  60.                 $request->getContent()
  61.             );
  62.         }
  64.         // As long as contao adds unused parameters to $_GET and $_POST Globals inside \Contao\Input, we have to add them inside custom ParameterBag classes
  65.         $this->query = new QueryParameterBag($request && $request->query ? $request->query->all() : []);
  66.     }
  68.     /**
  69.      * For test purposes use \Symfony\Component\HttpFoundation\Request::create() for dummy data.
  70.      *
  71.      * @return \Symfony\Component\HttpFoundation\Request
  72.      */
  73.     public function setRequest(\Symfony\Component\HttpFoundation\Request $request)
  74.     {
  75.         $this->initialize($request->query->all(), $request->request->all(), $request->attributes->all(), $request->cookies->all(), $request->files->all(), $request->server->all(), $request->getContent());
  77.         // As long as contao adds unused parameters to $_GET and $_POST Globals inside \Contao\Input, we have to add them inside custom ParameterBag classes
  78.         $this->query = new QueryParameterBag($request->query->all());
  80.         return $this;
  81.     }
  83.     /**
  84.      * Shorthand setter for query arguments ($_GET).
  85.      *
  86.      * @param string $key   The requested field
  87.      * @param mixed  $value The input value
  88.      */
  89.     public function setGet(string $key, $value)
  90.     {
  91.         // Convert special characters (see #7829)
  92.         $key = str_replace([' ', '.', '['], '_', $key);
  94.         $key = Input::cleanKey($key);
  96.         if (null === $value) {
  97.             $this->query->remove($key);
  98.         } else {
  99.             $this->query->set($key, $value);
  100.         }
  101.     }
  103.     /**
  104.      * Shorthand setter for request arguments ($_POST).
  105.      *
  106.      * @param string $key   The requested field
  107.      * @param mixed  $value The input value
  108.      */
  109.     public function setPost(string $key, $value)
  110.     {
  111.         $key = Input::cleanKey($key);
  113.         if (null === $value) {
  114.             $this->request->remove($key);
  115.         } else {
  116.             $this->request->set($key, $value);
  117.         }
  118.     }
  120.     /**
  121.      * Shorthand getter for query arguments ($_GET).
  122.      *
  123.      * @param string $postKey        The requested field
  124.      * @param bool   $decodeEntities If true, all entities will be decoded
  125.      * @param bool   $tidy           If true, varValue is tidied up
  126.      *
  127.      * @return mixed If no $strkey is defined, return all cleaned query parameters, otherwise the cleaned requested query value
  128.      */
  129.     public function getGet(string $postKey = null, bool $decodeEntities = false, bool $tidy = false)
  130.     {
  131.         if (null === $postKey) {
  132.             $postValues = $this->query;
  134.             if ($decodeEntities) {
  135.                 foreach ($postValues as $key => &$value) {
  136.                     $value = $this->clean($value, $decodeEntities, true, $tidy);
  137.                 }
  138.             }
  140.             return $postValues;
  141.         }
  143.         return $this->clean($this->query->get($postKey), $decodeEntities, true, $tidy);
  144.     }
  146.     /**
  147.      * XSS clean, decodeEntities, tidy/strip tags, encode special characters and encode inserttags and return save, cleaned value(s).
  148.      *
  149.      * @param mixed $value            The input value
  150.      * @param bool  $decodeEntities   If true, all entities will be decoded
  151.      * @param bool  $encodeInsertTags If true, encode the opening and closing delimiters of insert tags
  152.      * @param bool  $tidy             If true, varValue is tidied up
  153.      * @param bool  $strictMode       If true, the xss cleaner removes also JavaScript event handlers
  154.      *
  155.      * @return mixed The cleaned value
  156.      */
  157.     public function clean($value, bool $decodeEntities = false, bool $encodeInsertTags = true, bool $tidy = true, bool $strictMode = true)
  158.     {
  159.         // do not clean, otherwise empty string will be returned, not null
  160.         if (null === $value) {
  161.             return $value;
  162.         }
  164.         if (\is_array($value)) {
  165.             foreach ($value as $i => $childValue) {
  166.                 $value[$i] = $this->clean($childValue, $decodeEntities, $encodeInsertTags, $tidy, $strictMode);
  167.             }
  169.             return $value;
  170.         }
  172.         // do not handle binary uuid
  173.         if (Validator::isUuid($value)) {
  174.             return $value;
  175.         }
  177.         $value = $this->xssClean($value, $strictMode);
  179.         if ($tidy) {
  180.             $value = $this->tidy($value);
  181.         } else {
  182.             // decodeEntities for tidy is more complex, because non allowed tags should be displayed as readable text, not as html entity
  183.             $value = Input::decodeEntities($value);
  184.         }
  186.         // do not encodeSpecialChars when tidy did run, otherwise non allowed tags will be encoded twice
  187.         if (!$decodeEntities && !$tidy) {
  188.             $value = Input::encodeSpecialChars($value);
  189.         }
  191.         if ($encodeInsertTags) {
  192.             $value = Input::encodeInsertTags($value);
  193.         }
  195.         return $value;
  196.     }
  198.     /**
  199.      * XSS clean, decodeEntities, tidy/strip tags, encode special characters and encode inserttags and return save, cleaned value(s).
  200.      *
  201.      * @param mixed  $value            The input value
  202.      * @param bool   $decodeEntities   If true, all entities will be decoded
  203.      * @param bool   $encodeInsertTags If true, encode the opening and closing delimiters of insert tags
  204.      * @param string $allowedTags      List of allowed html tags
  205.      * @param bool   $tidy             If true, varValue is tidied up
  206.      * @param bool   $strictMode       If true, the xss cleaner removes also JavaScript event handlers
  207.      *
  208.      * @return mixed The cleaned value
  209.      */
  210.     public function cleanHtml($value, bool $decodeEntities = false, bool $encodeInsertTags = true, string $allowedTags = '', bool $tidy = true, bool $strictMode = true)
  211.     {
  212.         // do not clean, otherwise empty string will be returned, not null
  213.         if (null === $value) {
  214.             return $value;
  215.         }
  217.         if (\is_array($value)) {
  218.             foreach ($value as $i => $childValue) {
  219.                 $value[$i] = $this->cleanHtml($childValue, $decodeEntities, $encodeInsertTags, $allowedTags, $tidy, $strictMode);
  220.             }
  222.             return $value;
  223.         }
  225.         // do not handle binary uuid
  226.         if (Validator::isUuid($value)) {
  227.             return $value;
  228.         }
  230.         $value = $this->xssClean($value, $strictMode);
  232.         if ($tidy) {
  233.             $value = $this->tidy($value, $allowedTags, $decodeEntities);
  234.         } else {
  235.             // decodeEntities for tidy is more complex, because non allowed tags should be displayed as readable text, not as html entity
  236.             $value = Input::decodeEntities($value);
  237.         }
  239.         // do not encodeSpecialChars when tidy did run, otherwise non allowed tags will be encoded twice
  240.         if (!$decodeEntities && !$tidy) {
  241.             $value = Input::encodeSpecialChars($value);
  242.         }
  244.         if ($encodeInsertTags) {
  245.             $value = Input::encodeInsertTags($value);
  246.         }
  248.         return $value;
  249.     }
  251.     /**
  252.      * XSS clean, preserve basic entities encode inserttags and return raw unsafe but filtered value.
  253.      *
  254.      * @param mixed $value            The input value
  255.      * @param bool  $encodeInsertTags If true, encode the opening and closing delimiters of insert tags
  256.      * @param bool  $tidy             If true, varValue is tidied up
  257.      * @param bool  $strictMode       If true, the xss cleaner removes also JavaScript event handlers
  258.      *
  259.      * @return mixed The cleaned value
  260.      */
  261.     public function cleanRaw($value, bool $encodeInsertTags = true, bool $tidy = false, bool $strictMode = false)
  262.     {
  263.         // do not clean, otherwise empty string will be returned, not null
  264.         if (null === $value) {
  265.             return $value;
  266.         }
  268.         if (\is_array($value)) {
  269.             foreach ($value as $i => $childValue) {
  270.                 $value[$i] = $this->cleanRaw($childValue, $encodeInsertTags, $tidy, $strictMode);
  271.             }
  273.             return $value;
  274.         }
  276.         // do not handle binary uuid
  277.         if (Validator::isUuid($value)) {
  278.             return $value;
  279.         }
  281.         $value = $this->xssClean($value, $strictMode);
  283.         if ($tidy) {
  284.             $value = $this->tidy($value);
  285.         }
  287.         $value = Input::preserveBasicEntities($value);
  289.         if ($encodeInsertTags) {
  290.             $value = Input::encodeInsertTags($value);
  291.         }
  293.         return $value;
  294.     }
  296.     /**
  297.      * Returns true if the get parameter is defined.
  298.      *
  299.      * @param string $key The key
  300.      *
  301.      * @return bool true if the parameter exists, false otherwise
  302.      */
  303.     public function hasGet(string $key)
  304.     {
  305.         return $this->query->has($key);
  306.     }
  308.     /**
  309.      * Shorthand getter for request arguments ($_POST).
  310.      *
  311.      * @param string $key            The requested field
  312.      * @param bool   $decodeEntities If true, all entities will be decoded
  313.      * @param bool   $tidy           If true, varValue is tidied up
  314.      * @param bool   $strictMode     If true, the xss cleaner removes also JavaScript event handlers
  315.      *
  316.      * @return mixed|null If no $strKey is defined, return all cleaned query parameters, otherwise the cleaned requested query value
  317.      */
  318.     public function getPost(string $key, bool $decodeEntities = false, bool $tidy = true, bool $strictMode = true)
  319.     {
  320.         if (!$this->request->has($key)) {
  321.             return null;
  322.         }
  324.         return $this->clean($this->request->get($key), $decodeEntities, $this->scopeMatcher->isFrontendRequest($this), $tidy, $strictMode);
  325.     }
  327.     /**
  328.      * Shorthand getter for request arguments ($_POST).
  329.      *
  330.      * @param string $strKey         The requested field
  331.      * @param bool   $decodeEntities If true, all entities will be decoded
  332.      * @param bool   $tidy           If true, varValue is tidied up
  333.      * @param bool   $strictMode     If true, the xss cleaner removes also JavaScript event handlers
  334.      *
  335.      * @return array If no $strKey is defined, return all cleaned query parameters, otherwise the cleaned requested query value
  336.      */
  337.     public function getAllPost(bool $decodeEntities = false, bool $tidy = true, bool $strictMode = true): array
  338.     {
  339.         $arrValues = $this->request->all();
  341.         if (empty($arrValues)) {
  342.             return $arrValues;
  343.         }
  345.         foreach ($arrValues as $key => &$varValue) {
  346.             $varValue = $this->clean($varValue, $decodeEntities, $this->scopeMatcher->isFrontendRequest($this), $tidy, $strictMode);
  347.         }
  349.         return $arrValues;
  350.     }
  352.     /**
  353.      * Shorthand getter for request arguments ($_POST) preserving allowed HTML tags.
  354.      *
  355.      * @param string $key            The requested field
  356.      * @param bool   $decodeEntities If true, all entities will be decoded
  357.      * @param string $allowedTags    List of allowed html tags
  358.      * @param bool   $tidy           If true, varValue is tidied up
  359.      * @param bool   $strictMode     If true, the xss cleaner removes also JavaScript event handlers
  360.      *
  361.      * @return mixed|null If no $strKey is defined, return all cleaned query parameters, otherwise the cleaned requested query value
  362.      */
  363.     public function getPostHtml(string $key, bool $decodeEntities = false, string $allowedTags = '', bool $tidy = true, bool $strictMode = true)
  364.     {
  365.         if (!$this->request->has($key)) {
  366.             return null;
  367.         }
  369.         return $this->cleanHtml($this->request->get($key), $decodeEntities, $this->scopeMatcher->isFrontendRequest($this), $allowedTags, $tidy, $strictMode);
  370.     }
  372.     /**
  373.      * Shorthand getter for request arguments ($_POST) preserving allowed HTML tags.
  374.      *
  375.      * @param string $strKey         The requested field
  376.      * @param bool   $decodeEntities If true, all entities will be decoded
  377.      * @param string $allowedTags    List of allowed html tags
  378.      * @param bool   $tidy           If true, varValue is tidied up
  379.      * @param bool   $strictMode     If true, the xss cleaner removes also JavaScript event handlers
  380.      */
  381.     public function getAllPostHtml(bool $decodeEntities = false, string $allowedTags = '', bool $tidy = true, bool $strictMode = true): array
  382.     {
  383.         $arrValues = $this->request->all();
  385.         if (empty($arrValues)) {
  386.             return $arrValues;
  387.         }
  389.         foreach ($arrValues as $key => &$varValue) {
  390.             $varValue = $this->cleanHtml($varValue, $decodeEntities, $this->scopeMatcher->isFrontendRequest($this), $allowedTags, $tidy, $strictMode);
  391.         }
  393.         return $arrValues;
  394.     }
  396.     /**
  397.      * Shorthand getter for request arguments ($_POST), returning raw, unsafe but filtered values.
  398.      *
  399.      * @param string $key        The requested field
  400.      * @param bool   $tidy       If true, varValue is tidied up
  401.      * @param bool   $strictMode If true, the xss cleaner removes also JavaScript event handlers
  402.      *
  403.      * @return mixed|null If no $strkey is defined, return all cleaned query parameters, otherwise the cleaned requested query value
  404.      */
  405.     public function getPostRaw(string $key, bool $tidy = false, bool $strictMode = false)
  406.     {
  407.         if (!$this->request->has($key)) {
  408.             return null;
  409.         }
  411.         return $this->cleanRaw($this->request->get($key), $this->scopeMatcher->isFrontendRequest($this), $tidy, $strictMode);
  412.     }
  414.     /**
  415.      * Shorthand getter for request arguments ($_POST), returning raw, unsafe but filtered values.
  416.      *
  417.      * @param string $strKey     The requested field
  418.      * @param bool   $tidy       If true, varValue is tidied up
  419.      * @param bool   $strictMode If true, the xss cleaner removes also JavaScript event handlers
  420.      */
  421.     public function getAllPostRaw(bool $tidy = false, bool $strictMode = false): array
  422.     {
  423.         $arrValues = $this->request->all();
  425.         if (empty($arrValues)) {
  426.             return $arrValues;
  427.         }
  429.         foreach ($arrValues as $key => &$varValue) {
  430.             $varValue = $this->cleanRaw($varValue, $this->scopeMatcher->isFrontendRequest($this), $tidy, $strictMode);
  431.         }
  433.         return $arrValues;
  434.     }
  436.     /**
  437.      * Clean a value and try to prevent XSS attacks.
  438.      *
  439.      * @param mixed $varValue   A string or array
  440.      * @param bool  $strictMode If true, the function removes also JavaScript event handlers
  441.      *
  442.      * @return mixed The cleaned string or array
  443.      */
  444.     public function xssClean($varValue, bool $strictMode = false)
  445.     {
  446.         if (\is_array($varValue)) {
  447.             foreach ($varValue as $key => $value) {
  448.                 $varValue[$key] = $this->xssClean($value, $strictMode);
  449.             }
  451.             return $varValue;
  452.         }
  454.         // do not xss clean binary uuids
  455.         if (Validator::isBinaryUuid($varValue)) {
  456.             return $varValue;
  457.         }
  459.         // Fix issue StringUtils::decodeEntites() returning empty string when value is 0 in some contao 4.9 versions
  460.         if ('0' !== $varValue && 0 !== $varValue) {
  461.             $varValue = StringUtil::decodeEntities($varValue);
  462.         }
  464.         $varValue = preg_replace('/(&#[A-Za-z0-9]+);?/i', '$1;', $varValue);
  466.         // fix: "><script>alert('xss')</script> or '></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83))</SCRIPT>
  467.         $varValue = preg_replace('/(?<!\w)(?>["|\']>)+(<[^\/^>]+>.*)/', '$1', $varValue);
  469.         $varValue = Input::xssClean($varValue, $strictMode);
  471.         return $varValue;
  472.     }
  474.     /**
  475.      * Tidy an value.
  476.      *
  477.      * @param string $varValue       Input value
  478.      * @param string $allowedTags    Allowed tags as string `<p><span>`
  479.      * @param bool   $decodeEntities If true, all entities will be decoded
  480.      *
  481.      * @return string The tidied string
  482.      */
  483.     public function tidy($varValue, string $allowedTags = '', bool $decodeEntities = false): string
  484.     {
  485.         if (!$varValue) {
  486.             return $varValue;
  487.         }
  489.         // do not tidy non-xss critical characters for performance
  490.         if (!preg_match('#"|\'|<|>|\(|\)#', StringUtil::decodeEntities($varValue))) {
  491.             return $varValue;
  492.         }
  494.         // remove illegal white spaces after closing tag slash <br / >
  495.         $varValue = preg_replace('@\/(\s+)>@', '/>', $varValue);
  497.         // Encode opening tag arrow brackets
  498.         $varValue = preg_replace_callback('/<(?(?=!--)!--[\s\S]*--|(?(?=\?)\?[\s\S]*\?|(?(?=\/)\/[^.\-\d][^\/\]\'"[!#$%&()*+,;<=>?@^`{|}~ ]*|[^.\-\d][^\/\]\'"[!#$%&()*+,;<=>?@^`{|}~ ]*(?:\s[^.\-\d][^\/\]\'"[!#$%&()*+,;<=>?@^`{|}~ ]*(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"<\s]*))?)*)\s?\/?))>/', function ($matches) {
  499.             return substr_replace($matches[0], '&lt;', 0, 1);
  500.         }, $varValue);
  502.         // Encode less than signs that are no tags with [lt]
  503.         $varValue = str_replace('<', '[lt]', $varValue);
  505.         // After we saved less than signs with [lt] revert &lt; sign to <
  506.         $varValue = StringUtil::decodeEntities($varValue);
  508.         // Restore HTML comments
  509.         $varValue = str_replace(['&lt;!--', '&lt;!['], ['<!--', '<!['], $varValue);
  511.         // Recheck for encoded null bytes
  512.         while (false !== strpos($varValue, '\\0')) {
  513.             $varValue = str_replace('\\0', '', $varValue);
  514.         }
  516.         $objCrawler = new HtmlPageCrawler($varValue);
  518.         if (!$objCrawler->isHtmlDocument()) {
  519.             $objCrawler = new HtmlPageCrawler('<div id="tidyWrapperx123x123xawec3">'.$varValue.'</div>');
  520.         }
  522.         $arrAllowedTags = explode('<', str_replace('>', '', $allowedTags));
  523.         $arrAllowedTags = array_filter($arrAllowedTags);
  525.         try {
  526.             if (!empty($arrAllowedTags)) {
  527.                 $objCrawler->filter('*')->each(function ($node, $i) use ($arrAllowedTags) {
  528.                     /** @var $node HtmlPageCrawler */
  530.                     // skip wrapper
  531.                     if ('tidyWrapperx123x123xawec3' === $node->getAttribute('id')) {
  532.                         return $node;
  533.                     }
  535.                     if (!\in_array($node->getNode(0)->tagName, $arrAllowedTags, true)) {
  536.                         $strHTML = $node->saveHTML();
  537.                         $strHTML = str_replace(['<', '>'], ['[[xlt]]', '[[xgt]]'], $strHTML);
  539.                         // remove unwanted tags and return the element text
  540.                         return $node->replaceWith($strHTML);
  541.                     }
  543.                     return $node;
  544.                 });
  545.             }
  546.             // unwrap div#tidyWrapper and set value to its innerHTML
  547.             if (!$objCrawler->isHtmlDocument()) {
  548.                 $varValue = $objCrawler->filter('div#tidyWrapperx123x123xawec3')->getInnerHtml();
  549.             } else {
  550.                 $varValue = $objCrawler->saveHTML();
  551.             }
  553.             // HTML documents or fragments, Crawler first converts all non-ASCII characters to entities (see: https://github.com/wasinger/htmlpagedom/issues/5)
  554.             $varValue = StringUtil::decodeEntities($varValue);
  556.             // trim last [nbsp] occurance
  557.             $varValue = preg_replace('@(\[nbsp\])+@', '', $varValue);
  558.         } catch (SyntaxErrorException $e) {
  559.         }
  561.         $varValue = $this->restoreBasicEntities($varValue, $decodeEntities);
  563.         if (!$decodeEntities) {
  564.             $varValue = Input::encodeSpecialChars($varValue);
  565.         }
  567.         // encode unwanted tag opening and closing brakets
  568.         $arrSearch = ['[[xlt]]', '[[xgt]]'];
  569.         $arrReplace = ['&#60;', '&#62;'];
  570.         $varValue = str_replace($arrSearch, $arrReplace, $varValue);
  572.         return $varValue;
  573.     }
  575.     /**
  576.      * Restore basic entities.
  577.      *
  578.      * @param string $buffer         The string with the tags to be replaced
  579.      * @param bool   $decodeEntities If true, all entities will be decoded
  580.      *
  581.      * @return string The string with the original entities
  582.      */
  583.     public function restoreBasicEntities(string $buffer, bool $decodeEntities = false): string
  584.     {
  585.         $buffer = str_replace(['[&]', '[&amp;]', '[lt]', '[gt]', '[nbsp]', '[-]'], ['&amp;', '&amp;', '&lt;', '&gt;', '&nbsp;', '&shy;'], $buffer);
  587.         if ($decodeEntities) {
  588.             $buffer = StringUtil::decodeEntities($buffer);
  589.         }
  591.         return $buffer;
  592.     }
  594.     /**
  595.      * Returns true if the post parameter is defined.
  596.      *
  597.      * @param string $key The key
  598.      *
  599.      * @return bool true if the parameter exists, false otherwise
  600.      */
  601.     public function hasPost(string $key): bool
  602.     {
  603.         return $this->request->has($key);
  604.     }
  606.     /**
  607.      * @param $request
  608.      *
  609.      * @return array
  610.      */
  611.     protected function checkCurrentRequest($request)
  612.     {
  613.         if (null === $request || !$request instanceof ParameterBag) {
  614.             return [];
  615.         }
  617.         $parameters = $request->all();
  619.         foreach ($parameters as $i => $parameter) {
  620.             if (null === $parameter) {
  621.                 unset($parameters[$i]);
  622.             }
  623.         }
  625.         return $parameters;
  626.     }
  627. }