vendor/nelmio/security-bundle/src/EventListener/ExternalRedirectListener.php line 69

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the Nelmio SecurityBundle.
  7.  *
  8.  * (c) Nelmio <hello@nelm.io>
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Nelmio\SecurityBundle\EventListener;
  16. use Nelmio\SecurityBundle\ExternalRedirect\AllowListBasedTargetValidator;
  17. use Nelmio\SecurityBundle\ExternalRedirect\TargetValidator;
  18. use Psr\Log\LoggerInterface;
  19. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  20. use Symfony\Component\HttpKernel\Exception\HttpException;
  21. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  23. final class ExternalRedirectListener
  24. {
  25.     use KernelEventForwardCompatibilityTrait;
  27.     private bool $abort;
  28.     private ?string $override;
  29.     private ?string $forwardAs;
  31.     private ?TargetValidator $targetValidator;
  32.     private ?LoggerInterface $logger;
  33.     private ?UrlGeneratorInterface $generator;
  35.     /**
  36.      * @param bool                                     $abort           If true, the offending redirects are turned into 403 responses, can't be combined with $override
  37.      * @param string|null                              $override        Absolute path, complete URL or route name that must be used instead of the offending redirect's url
  38.      * @param string|null                              $forwardAs       Name of the route-/query string parameter the blocked url will be passed to destination location
  39.      * @param string|list<string>|TargetValidator|null $targetValidator array of hosts to be allowed, or regex that matches allowed hosts, or implementation of TargetValidator
  40.      * @param LoggerInterface|null                     $logger          A logger, if it's present, detected offenses are logged at the warning level
  41.      * @param UrlGeneratorInterface|null               $generator       Router or equivalent that can generate a route, only if override is a route name
  42.      */
  43.     public function __construct(
  44.         bool $abort = true,
  45.         ?string $override = null,
  46.         ?string $forwardAs = null,
  47.         $targetValidator = null,
  48.         ?LoggerInterface $logger = null,
  49.         ?UrlGeneratorInterface $generator = null
  50.     ) {
  51.         if (null !== $override && $abort) {
  52.             throw new \LogicException('The ExternalRedirectListener can not abort *and* override redirects at the same time.');
  53.         }
  54.         $this->abort = $abort;
  55.         $this->override = $override;
  56.         $this->forwardAs = $forwardAs;
  58.         if (\is_string($targetValidator) || \is_array($targetValidator)) {
  59.             $targetValidator = new AllowListBasedTargetValidator($targetValidator);
  60.         } elseif (null !== $targetValidator && !$targetValidator instanceof TargetValidator) {
  61.             throw new \LogicException('$targetValidator should be an array of hosts, a regular expression, or an implementation of TargetValidator.');
  62.         }
  63.         $this->targetValidator = $targetValidator;
  65.         $this->logger = $logger;
  66.         $this->generator = $generator;
  67.     }
  69.     public function onKernelResponse(ResponseEvent $e): void
  70.     {
  71.         if (!$this->isMainRequest($e)) {
  72.             return;
  73.         }
  75.         $response = $e->getResponse();
  77.         if (!$response->isRedirect()) {
  78.             return;
  79.         }
  81.         $target = $response->headers->get('Location');
  83.         if (null === $target) {
  84.             return;
  85.         }
  87.         if (!$this->isExternalRedirect($e->getRequest()->getUri(), $target)) {
  88.             return;
  89.         }
  91.         if (null !== $this->targetValidator && $this->targetValidator->isTargetAllowed($target)) {
  92.             return;
  93.         }
  95.         if (null !== $this->logger) {
  96.             $this->logger->warning('External redirect detected from '.$e->getRequest()->getUri().' to '.$response->headers->get('Location'));
  97.         }
  99.         if ($this->abort) {
  100.             throw new HttpException(403, 'Invalid Redirect Given: '.$response->headers->get('Location'));
  101.         }
  103.         if (null !== $this->override) {
  104.             $parameters = [];
  105.             if (null !== $this->forwardAs) {
  106.                 $parameters[$this->forwardAs] = $response->headers->get('Location');
  107.             }
  109.             if (false === strpos($this->override, '/')) {
  110.                 if (null === $this->generator) {
  111.                     throw new \UnexpectedValueException('The listener needs a router/UrlGeneratorInterface object to override invalid redirects with routes');
  112.                 }
  113.                 $response->headers->set('Location', $this->generator->generate($this->override, $parameters));
  114.             } else {
  115.                 $query = '';
  116.                 if (\count($parameters) > 0) {
  117.                     $query = (false === strpos($this->override, '?')) ? '?' : '&';
  118.                     $query .= http_build_query($parameters, '', '&');
  119.                 }
  120.                 $response->headers->set('Location', $this->override.$query);
  121.             }
  122.         }
  123.     }
  125.     public function isExternalRedirect(string $source, string $target): bool
  126.     {
  127.         // cleanup "\rhttp://foo.com/" and other null prefixeds to be scanned as valid internal redirect
  128.         $target = trim($target);
  130.         // handle protocol-relative URLs that parse_url() doesn't like
  131.         if ('//' === substr($target, 0, 2)) {
  132.             $target = 'proto:'.$target;
  133.         }
  135.         $parsedTarget = parse_url($target);
  136.         if (false === $parsedTarget || !isset($parsedTarget['host'])) {
  137.             return false;
  138.         }
  140.         $parsedSource = parse_url($source);
  141.         if (false === $parsedSource || !isset($parsedSource['host'])) {
  142.             throw new \LogicException('The source url must include a host name.');
  143.         }
  145.         return $parsedSource['host'] !== $parsedTarget['host'];
  146.     }
  147. }