Deprecated: Optional parameter $limit declared before required parameter $order is implicitly treated as a required parameter in /home/u536844918/domains/danzelklassic.com/siteFiles/lib/boab/cms-bundle/src/Repository/ContentRepositoryInterface.php on line 33

Deprecated: Optional parameter $limit declared before required parameter $order is implicitly treated as a required parameter in /home/u536844918/domains/danzelklassic.com/siteFiles/lib/boab/cms-bundle/src/Repository/ContentRepository.php on line 316

Deprecated: Optional parameter $orderBy declared before required parameter $order is implicitly treated as a required parameter in /home/u536844918/domains/danzelklassic.com/siteFiles/lib/boab/cms-bundle/src/Repository/ContentRepository.php on line 316

Deprecated: Optional parameter $data declared before required parameter $page is implicitly treated as a required parameter in /home/u536844918/domains/danzelklassic.com/siteFiles/lib/boab/cms-bundle/src/Manager/ContentTypeManager.php on line 178
Symfony Profiler

vendor/symfony/security-http/Firewall/ContextListener.php line 44

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Security\Http\Firewall;
  14. use Psr\Log\LoggerInterface;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\Session\Session;
  17. use Symfony\Component\HttpKernel\Event\RequestEvent;
  18. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  19. use Symfony\Component\HttpKernel\KernelEvents;
  20. use Symfony\Component\Security\Core\Authentication\AuthenticationTrustResolver;
  21. use Symfony\Component\Security\Core\Authentication\AuthenticationTrustResolverInterface;
  22. use Symfony\Component\Security\Core\Authentication\Token\AbstractToken;
  23. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  24. use Symfony\Component\Security\Core\Authentication\Token\SwitchUserToken;
  25. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  26. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  27. use Symfony\Component\Security\Core\Exception\UserNotFoundException;
  28. use Symfony\Component\Security\Core\User\EquatableInterface;
  29. use Symfony\Component\Security\Core\User\LegacyPasswordAuthenticatedUserInterface;
  30. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  31. use Symfony\Component\Security\Core\User\UserInterface;
  32. use Symfony\Component\Security\Core\User\UserProviderInterface;
  33. use Symfony\Component\Security\Http\Event\TokenDeauthenticatedEvent;
  34. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  36. /**
  37.  * ContextListener manages the SecurityContext persistence through a session.
  38.  *
  39.  * @author Fabien Potencier <fabien@symfony.com>
  40.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  41.  *
  42.  * @final
  43.  */
  44. class ContextListener extends AbstractListener
  45. {
  46.     private TokenStorageInterface $tokenStorage;
  47.     private string $sessionKey;
  48.     private ?LoggerInterface $logger;
  49.     private iterable $userProviders;
  50.     private ?EventDispatcherInterface $dispatcher;
  51.     private bool $registered = false;
  52.     private AuthenticationTrustResolverInterface $trustResolver;
  53.     private ?\Closure $sessionTrackerEnabler;
  55.     /**
  56.      * @param iterable<mixed, UserProviderInterface> $userProviders
  57.      */
  58.     public function __construct(TokenStorageInterface $tokenStorage, iterable $userProviders, string $contextKey, LoggerInterface $logger = null, EventDispatcherInterface $dispatcher = null, AuthenticationTrustResolverInterface $trustResolver = null, callable $sessionTrackerEnabler = null)
  59.     {
  60.         if (empty($contextKey)) {
  61.             throw new \InvalidArgumentException('$contextKey must not be empty.');
  62.         }
  64.         $this->tokenStorage = $tokenStorage;
  65.         $this->userProviders = $userProviders;
  66.         $this->sessionKey = '_security_'.$contextKey;
  67.         $this->logger = $logger;
  68.         $this->dispatcher = $dispatcher;
  70.         $this->trustResolver = $trustResolver ?? new AuthenticationTrustResolver();
  71.         $this->sessionTrackerEnabler = null === $sessionTrackerEnabler ? null : $sessionTrackerEnabler(...);
  72.     }
  74.     /**
  75.      * {@inheritdoc}
  76.      */
  77.     public function supports(Request $request): ?bool
  78.     {
  79.         return null; // always run authenticate() lazily with lazy firewalls
  80.     }
  82.     /**
  83.      * Reads the Security Token from the session.
  84.      */
  85.     public function authenticate(RequestEvent $event)
  86.     {
  87.         if (!$this->registered && null !== $this->dispatcher && $event->isMainRequest()) {
  88.             $this->dispatcher->addListener(KernelEvents::RESPONSE, $this->onKernelResponse(...));
  89.             $this->registered = true;
  90.         }
  92.         $request = $event->getRequest();
  93.         $session = $request->hasPreviousSession() && $request->hasSession() ? $request->getSession() : null;
  95.         $request->attributes->set('_security_firewall_run', $this->sessionKey);
  97.         if (null !== $session) {
  98.             $usageIndexValue = $session instanceof Session ? $usageIndexReference = &$session->getUsageIndex() : 0;
  99.             $usageIndexReference = \PHP_INT_MIN;
  100.             $sessionId = $request->cookies->all()[$session->getName()] ?? null;
  101.             $token = $session->get($this->sessionKey);
  103.             // sessionId = true is used in the tests
  104.             if ($this->sessionTrackerEnabler && \in_array($sessionId, [true, $session->getId()], true)) {
  105.                 $usageIndexReference = $usageIndexValue;
  106.             } else {
  107.                 $usageIndexReference = $usageIndexReference - \PHP_INT_MIN + $usageIndexValue;
  108.             }
  109.         }
  111.         if (null === $session || null === $token) {
  112.             if ($this->sessionTrackerEnabler) {
  113.                 ($this->sessionTrackerEnabler)();
  114.             }
  116.             $this->tokenStorage->setToken(null);
  118.             return;
  119.         }
  121.         $token = $this->safelyUnserialize($token);
  123.         $this->logger?->debug('Read existing security token from the session.', [
  124.             'key' => $this->sessionKey,
  125.             'token_class' => \is_object($token) ? \get_class($token) : null,
  126.         ]);
  128.         if ($token instanceof TokenInterface) {
  129.             $originalToken = $token;
  130.             $token = $this->refreshUser($token);
  132.             if (!$token) {
  133.                 $this->logger?->debug('Token was deauthenticated after trying to refresh it.');
  135.                 $this->dispatcher?->dispatch(new TokenDeauthenticatedEvent($originalToken, $request));
  136.             }
  137.         } elseif (null !== $token) {
  138.             $this->logger?->warning('Expected a security token from the session, got something else.', ['key' => $this->sessionKey, 'received' => $token]);
  140.             $token = null;
  141.         }
  143.         if ($this->sessionTrackerEnabler) {
  144.             ($this->sessionTrackerEnabler)();
  145.         }
  147.         $this->tokenStorage->setToken($token);
  148.     }
  150.     /**
  151.      * Writes the security token into the session.
  152.      */
  153.     public function onKernelResponse(ResponseEvent $event)
  154.     {
  155.         if (!$event->isMainRequest()) {
  156.             return;
  157.         }
  159.         $request = $event->getRequest();
  161.         if (!$request->hasSession() || $request->attributes->get('_security_firewall_run') !== $this->sessionKey) {
  162.             return;
  163.         }
  165.         $this->dispatcher?->removeListener(KernelEvents::RESPONSE, $this->onKernelResponse(...));
  166.         $this->registered = false;
  167.         $session = $request->getSession();
  168.         $sessionId = $session->getId();
  169.         $usageIndexValue = $session instanceof Session ? $usageIndexReference = &$session->getUsageIndex() : null;
  170.         $token = $this->tokenStorage->getToken();
  172.         if (!$this->trustResolver->isAuthenticated($token)) {
  173.             if ($request->hasPreviousSession()) {
  174.                 $session->remove($this->sessionKey);
  175.             }
  176.         } else {
  177.             $session->set($this->sessionKey, serialize($token));
  179.             $this->logger?->debug('Stored the security token in the session.', ['key' => $this->sessionKey]);
  180.         }
  182.         if ($this->sessionTrackerEnabler && $session->getId() === $sessionId) {
  183.             $usageIndexReference = $usageIndexValue;
  184.         }
  185.     }
  187.     /**
  188.      * Refreshes the user by reloading it from the user provider.
  189.      *
  190.      * @throws \RuntimeException
  191.      */
  192.     protected function refreshUser(TokenInterface $token): ?TokenInterface
  193.     {
  194.         $user = $token->getUser();
  196.         $userNotFoundByProvider = false;
  197.         $userDeauthenticated = false;
  198.         $userClass = \get_class($user);
  200.         foreach ($this->userProviders as $provider) {
  201.             if (!$provider instanceof UserProviderInterface) {
  202.                 throw new \InvalidArgumentException(sprintf('User provider "%s" must implement "%s".', get_debug_type($provider), UserProviderInterface::class));
  203.             }
  205.             if (!$provider->supportsClass($userClass)) {
  206.                 continue;
  207.             }
  209.             try {
  210.                 $refreshedUser = $provider->refreshUser($user);
  211.                 $newToken = clone $token;
  212.                 $newToken->setUser($refreshedUser, false);
  214.                 // tokens can be deauthenticated if the user has been changed.
  215.                 if ($token instanceof AbstractToken && $this->hasUserChanged($user, $newToken)) {
  216.                     $userDeauthenticated = true;
  218.                     $this->logger?->debug('Cannot refresh token because user has changed.', ['username' => $refreshedUser->getUserIdentifier(), 'provider' => \get_class($provider)]);
  220.                     continue;
  221.                 }
  223.                 $token->setUser($refreshedUser);
  225.                 if (null !== $this->logger) {
  226.                     $context = ['provider' => \get_class($provider), 'username' => $refreshedUser->getUserIdentifier()];
  228.                     if ($token instanceof SwitchUserToken) {
  229.                         $originalToken = $token->getOriginalToken();
  230.                         $context['impersonator_username'] = $originalToken->getUserIdentifier();
  231.                     }
  233.                     $this->logger->debug('User was reloaded from a user provider.', $context);
  234.                 }
  236.                 return $token;
  237.             } catch (UnsupportedUserException) {
  238.                 // let's try the next user provider
  239.             } catch (UserNotFoundException $e) {
  240.                 $this->logger?->warning('Username could not be found in the selected user provider.', ['username' => $e->getUserIdentifier(), 'provider' => \get_class($provider)]);
  242.                 $userNotFoundByProvider = true;
  243.             }
  244.         }
  246.         if ($userDeauthenticated) {
  247.             return null;
  248.         }
  250.         if ($userNotFoundByProvider) {
  251.             return null;
  252.         }
  254.         throw new \RuntimeException(sprintf('There is no user provider for user "%s". Shouldn\'t the "supportsClass()" method of your user provider return true for this classname?', $userClass));
  255.     }
  257.     private function safelyUnserialize(string $serializedToken)
  258.     {
  259.         $token = null;
  260.         $prevUnserializeHandler = ini_set('unserialize_callback_func', __CLASS__.'::handleUnserializeCallback');
  261.         $prevErrorHandler = set_error_handler(function ($type, $msg, $file, $line, $context = []) use (&$prevErrorHandler) {
  262.             if (__FILE__ === $file) {
  263.                 throw new \ErrorException($msg, 0x37313BC, $type, $file, $line);
  264.             }
  266.             return $prevErrorHandler ? $prevErrorHandler($type, $msg, $file, $line, $context) : false;
  267.         });
  269.         try {
  270.             $token = unserialize($serializedToken);
  271.         } catch (\ErrorException $e) {
  272.             if (0x37313BC !== $e->getCode()) {
  273.                 throw $e;
  274.             }
  275.             $this->logger?->warning('Failed to unserialize the security token from the session.', ['key' => $this->sessionKey, 'received' => $serializedToken, 'exception' => $e]);
  276.         } finally {
  277.             restore_error_handler();
  278.             ini_set('unserialize_callback_func', $prevUnserializeHandler);
  279.         }
  281.         return $token;
  282.     }
  284.     private static function hasUserChanged(UserInterface $originalUser, TokenInterface $refreshedToken): bool
  285.     {
  286.         $refreshedUser = $refreshedToken->getUser();
  288.         if ($originalUser instanceof EquatableInterface) {
  289.             return !(bool) $originalUser->isEqualTo($refreshedUser);
  290.         }
  292.         if ($originalUser instanceof PasswordAuthenticatedUserInterface || $refreshedUser instanceof PasswordAuthenticatedUserInterface) {
  293.             if (!$originalUser instanceof PasswordAuthenticatedUserInterface || !$refreshedUser instanceof PasswordAuthenticatedUserInterface || $originalUser->getPassword() !== $refreshedUser->getPassword()) {
  294.                 return true;
  295.             }
  297.             if ($originalUser instanceof LegacyPasswordAuthenticatedUserInterface xor $refreshedUser instanceof LegacyPasswordAuthenticatedUserInterface) {
  298.                 return true;
  299.             }
  301.             if ($originalUser instanceof LegacyPasswordAuthenticatedUserInterface && $refreshedUser instanceof LegacyPasswordAuthenticatedUserInterface && $originalUser->getSalt() !== $refreshedUser->getSalt()) {
  302.                 return true;
  303.             }
  304.         }
  306.         $userRoles = array_map('strval', (array) $refreshedUser->getRoles());
  308.         if ($refreshedToken instanceof SwitchUserToken) {
  309.             $userRoles[] = 'ROLE_PREVIOUS_ADMIN';
  310.         }
  312.         if (
  313.             \count($userRoles) !== \count($refreshedToken->getRoleNames()) ||
  314.             \count($userRoles) !== \count(array_intersect($userRoles, $refreshedToken->getRoleNames()))
  315.         ) {
  316.             return true;
  317.         }
  319.         if ($originalUser->getUserIdentifier() !== $refreshedUser->getUserIdentifier()) {
  320.             return true;
  321.         }
  323.         return false;
  324.     }
  326.     /**
  327.      * @internal
  328.      */
  329.     public static function handleUnserializeCallback(string $class)
  330.     {
  331.         throw new \ErrorException('Class not found: '.$class, 0x37313BC);
  332.     }
  333. }