vendor/nelmio/security-bundle/src/EventListener/ContentSecurityPolicyListener.php line 136

  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\ContentSecurityPolicy\DirectiveSet;
  17. use Nelmio\SecurityBundle\ContentSecurityPolicy\NonceGeneratorInterface;
  18. use Nelmio\SecurityBundle\ContentSecurityPolicy\ShaComputerInterface;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpKernel\Event\RequestEvent;
  21. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  22. use Symfony\Component\HttpKernel\KernelEvents;
  24. final class ContentSecurityPolicyListener extends AbstractContentTypeRestrictableListener
  25. {
  26.     use KernelEventForwardCompatibilityTrait;
  28.     private DirectiveSet $report;
  29.     private DirectiveSet $enforce;
  30.     private bool $compatHeaders;
  32.     /**
  33.      * @var list<string>
  34.      */
  35.     private array $hosts;
  36.     private ?string $_nonce = null;
  37.     private ?string $scriptNonce = null;
  38.     private ?string $styleNonce = null;
  40.     /**
  41.      * @var array<string, list<string>>|null
  42.      */
  43.     private ?array $sha = null;
  44.     private NonceGeneratorInterface $nonceGenerator;
  45.     private ShaComputerInterface $shaComputer;
  47.     /**
  48.      * @param list<string> $hosts
  49.      * @param list<string> $contentTypes
  50.      */
  51.     public function __construct(
  52.         DirectiveSet $report,
  53.         DirectiveSet $enforce,
  54.         NonceGeneratorInterface $nonceGenerator,
  55.         ShaComputerInterface $shaComputer,
  56.         bool $compatHeaders = true,
  57.         array $hosts = [],
  58.         array $contentTypes = []
  59.     ) {
  60.         parent::__construct($contentTypes);
  61.         $this->report = $report;
  62.         $this->enforce = $enforce;
  63.         $this->compatHeaders = $compatHeaders;
  64.         $this->hosts = $hosts;
  65.         $this->nonceGenerator = $nonceGenerator;
  66.         $this->shaComputer = $shaComputer;
  67.     }
  69.     public function onKernelRequest(RequestEvent $e): void
  70.     {
  71.         if (!$this->isMainRequest($e)) {
  72.             return;
  73.         }
  75.         $this->sha = [];
  76.     }
  78.     public function addSha(string $directive, string $sha): void
  79.     {
  80.         if (null === $this->sha) {
  81.             // We're not in a request context, probably in a worker
  82.             // let's disable it to avoid memory leak
  83.             return;
  84.         }
  86.         $this->sha[$directive][] = $sha;
  87.     }
  89.     public function addScript(string $html): void
  90.     {
  91.         if (null === $this->sha) {
  92.             // We're not in a request context, probably in a worker
  93.             // let's disable it to avoid memory leak
  94.             return;
  95.         }
  97.         $this->sha['script-src'][] = $this->shaComputer->computeForScript($html);
  98.     }
  100.     public function addStyle(string $html): void
  101.     {
  102.         if (null === $this->sha) {
  103.             // We're not in a request context, probably in a worker
  104.             // let's disable it to avoid memory leak
  105.             return;
  106.         }
  108.         $this->sha['style-src'][] = $this->shaComputer->computeForStyle($html);
  109.     }
  111.     public function getReport(): DirectiveSet
  112.     {
  113.         return $this->report;
  114.     }
  116.     public function getEnforcement(): DirectiveSet
  117.     {
  118.         return $this->enforce;
  119.     }
  121.     public function getNonce(string $usage): string
  122.     {
  123.         $nonce = $this->doGetNonce();
  125.         if ('script' === $usage) {
  126.             $this->scriptNonce = $nonce;
  127.         } elseif ('style' === $usage) {
  128.             $this->styleNonce = $nonce;
  129.         } else {
  130.             throw new \InvalidArgumentException('Invalid usage provided');
  131.         }
  133.         return $nonce;
  134.     }
  136.     public function onKernelResponse(ResponseEvent $e): void
  137.     {
  138.         if (!$this->isMainRequest($e)) {
  139.             return;
  140.         }
  142.         $request = $e->getRequest();
  143.         $response = $e->getResponse();
  145.         if ($response->isRedirection()) {
  146.             $this->_nonce = null;
  147.             $this->styleNonce = null;
  148.             $this->scriptNonce = null;
  149.             $this->sha = null;
  151.             return;
  152.         }
  154.         if (([] === $this->hosts || \in_array($e->getRequest()->getHost(), $this->hosts, true)) && $this->isContentTypeValid($response)) {
  155.             $signatures = $this->sha;
  156.             if (null !== $this->scriptNonce) {
  157.                 $signatures['script-src'][] = 'nonce-'.$this->scriptNonce;
  158.             }
  159.             if (null !== $this->styleNonce) {
  160.                 $signatures['style-src'][] = 'nonce-'.$this->styleNonce;
  161.             }
  163.             $response->headers->add($this->buildHeaders($request, $this->report, true, $this->compatHeaders, $signatures));
  164.             $response->headers->add($this->buildHeaders($request, $this->enforce, false, $this->compatHeaders, $signatures));
  165.         }
  167.         $this->_nonce = null;
  168.         $this->styleNonce = null;
  169.         $this->scriptNonce = null;
  170.         $this->sha = null;
  171.     }
  173.     public static function getSubscribedEvents(): array
  174.     {
  175.         return [
  176.             KernelEvents::REQUEST => ['onKernelRequest', 512],
  177.             KernelEvents::RESPONSE => 'onKernelResponse',
  178.         ];
  179.     }
  181.     private function doGetNonce(): string
  182.     {
  183.         if (null === $this->_nonce) {
  184.             $this->_nonce = $this->nonceGenerator->generate();
  185.         }
  187.         return $this->_nonce;
  188.     }
  190.     /**
  191.      * @param array<string, list<string>>|null $signatures
  192.      *
  193.      * @return array<string, string>
  194.      */
  195.     private function buildHeaders(
  196.         Request $request,
  197.         DirectiveSet $directiveSet,
  198.         bool $reportOnly,
  199.         bool $compatHeaders,
  200.         array $signatures = null
  201.     ): array {
  202.         // $signatures might be null if no KernelEvents::REQUEST has been triggered.
  203.         // for instance if a security.authentication.failure has been dispatched
  204.         $headerValue = $directiveSet->buildHeaderValue($request, $signatures);
  206.         if ('' === $headerValue) {
  207.             return [];
  208.         }
  210.         $hn = static function (string $name) use ($reportOnly): string {
  211.             return $name.($reportOnly ? '-Report-Only' : '');
  212.         };
  214.         $headers = [
  215.             $hn('Content-Security-Policy') => $headerValue,
  216.         ];
  218.         if ($compatHeaders) {
  219.             $headers[$hn('X-Content-Security-Policy')] = $headerValue;
  220.         }
  222.         return $headers;
  223.     }
  224. }