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

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\Security\Http\Firewall;
  11. use Psr\Log\LoggerInterface;
  12. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  13. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  14. use Symfony\Component\HttpKernel\Event\GetResponseEvent;
  15. use Symfony\Component\HttpKernel\KernelEvents;
  16. use Symfony\Component\Security\Core\Authentication\AuthenticationTrustResolver;
  17. use Symfony\Component\Security\Core\Authentication\AuthenticationTrustResolverInterface;
  18. use Symfony\Component\Security\Core\Authentication\Token\AnonymousToken;
  19. use Symfony\Component\Security\Core\Authentication\Token\RememberMeToken;
  20. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  21. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  22. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  23. use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
  24. use Symfony\Component\Security\Core\Role\SwitchUserRole;
  25. use Symfony\Component\Security\Core\User\UserInterface;
  26. use Symfony\Component\Security\Core\User\UserProviderInterface;
  27. /**
  28.  * ContextListener manages the SecurityContext persistence through a session.
  29.  *
  30.  * @author Fabien Potencier <fabien@symfony.com>
  31.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  32.  */
  33. class ContextListener implements ListenerInterface {
  34.     private $tokenStorage;
  35.     private $sessionKey;
  36.     private $logger;
  37.     private $userProviders;
  38.     private $dispatcher;
  39.     private $registered;
  40.     private $trustResolver;
  41.     /**
  42.      * @param iterable|UserProviderInterface[] $userProviders
  43.      */
  44.     public function __construct(TokenStorageInterface $tokenStorageiterable $userProvidersstring $contextKeyLoggerInterface $logger nullEventDispatcherInterface $dispatcher nullAuthenticationTrustResolverInterface $trustResolver null) {
  45.         if (empty($contextKey)) {
  46.             throw new \InvalidArgumentException('$contextKey must not be empty.');
  47.         }
  48.         $this->tokenStorage $tokenStorage;
  49.         $this->userProviders $userProviders;
  50.         $this->sessionKey '_security_' $contextKey;
  51.         $this->logger $logger;
  52.         $this->dispatcher $dispatcher;
  53.         $this->trustResolver $trustResolver ?: new AuthenticationTrustResolver(AnonymousToken::class, RememberMeToken::class);
  54.     }
  55.     /**
  56.      * Enables deauthentication during refreshUser when the user has changed.
  57.      *
  58.      * @param bool $logoutOnUserChange
  59.      *
  60.      * @deprecated since Symfony 4.1
  61.      */
  62.     public function setLogoutOnUserChange($logoutOnUserChange) {
  63.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.1.'__METHOD__), E_USER_DEPRECATED);
  64.     }
  65.     /**
  66.      * Reads the Security Token from the session.
  67.      */
  68.     public function handle(GetResponseEvent $event) {
  69.         if (!$this->registered && null !== $this->dispatcher && $event->isMasterRequest()) {
  70.             $this->dispatcher->addListener(KernelEvents::RESPONSE, [$this'onKernelResponse']);
  71.             $this->registered true;
  72.         }
  73.         $request $event->getRequest();
  74.         $session $request->hasPreviousSession() ? $request->getSession() : null;
  75.         if (null === $session || null === $token $session->get($this->sessionKey)) {
  76.             $this->tokenStorage->setToken(null);
  77.             return;
  78.         }
  79.         $token $this->safelyUnserialize($token);
  80.         if (null !== $this->logger) {
  81.             $this->logger->debug('Read existing security token from the session.', [
  82.                 'key' => $this->sessionKey,
  83.                 'token_class' => \is_object($token) ? \get_class($token) : null,
  84.             ]);
  85.         }
  86.         if ($token instanceof TokenInterface) {
  87.             $token $this->refreshUser($token);
  88.         } elseif (null !== $token) {
  89.             if (null !== $this->logger) {
  90.                 $this->logger->warning('Expected a security token from the session, got something else.', ['key' => $this->sessionKey'received' => $token]);
  91.             }
  92.             $token null;
  93.         }
  94.         $this->tokenStorage->setToken($token);
  95.     }
  96.     /**
  97.      * Writes the security token into the session.
  98.      */
  99.     public function onKernelResponse(FilterResponseEvent $event) {
  100.         if (!$event->isMasterRequest()) {
  101.             return;
  102.         }
  103.         $request $event->getRequest();
  104.         if (!$request->hasSession()) {
  105.             return;
  106.         }
  107.         $this->dispatcher->removeListener(KernelEvents::RESPONSE, [$this'onKernelResponse']);
  108.         $this->registered false;
  109.         $session $request->getSession();
  110.         if ((null === $token $this->tokenStorage->getToken()) || $this->trustResolver->isAnonymous($token)) {
  111.             if ($request->hasPreviousSession()) {
  112.                 $session->remove($this->sessionKey);
  113.             }
  114.         } else {
  115.             $session->set($this->sessionKeyserialize($token));
  116.             if (null !== $this->logger) {
  117.                 $this->logger->debug('Stored the security token in the session.', ['key' => $this->sessionKey]);
  118.             }
  119.         }
  120.     }
  121.     /**
  122.      * Refreshes the user by reloading it from the user provider.
  123.      *
  124.      * @return TokenInterface|null
  125.      *
  126.      * @throws \RuntimeException
  127.      */
  128.     protected function refreshUser(TokenInterface $token) {
  129.         $user $token->getUser();
  130.         if (!$user instanceof UserInterface) {
  131.             return $token;
  132.         }
  133.         $userNotFoundByProvider false;
  134.         $userDeauthenticated false;
  135.         foreach ($this->userProviders as $provider) {
  136.             if (!$provider instanceof UserProviderInterface) {
  137.                 throw new \InvalidArgumentException(sprintf('User provider "%s" must implement "%s".', \get_class($provider), UserProviderInterface::class));
  138.             }
  139.             try {
  140.                 $refreshedUser $provider->refreshUser($user);
  141.                 $newToken = clone $token;
  142.                 $newToken->setUser($refreshedUser);
  143.                 // tokens can be deauthenticated if the user has been changed.
  144.                 if (!$newToken->isAuthenticated()) {
  145.                     $userDeauthenticated true;
  146.                     if (null !== $this->logger) {
  147.                         $this->logger->debug('Cannot refresh token because user has changed.', ['username' => $refreshedUser->getUsername(), 'provider' => \get_class($provider)]);
  148.                     }
  149.                     continue;
  150.                 }
  151.                 $token->setUser($refreshedUser);
  152.                 if (null !== $this->logger) {
  153.                     $context = ['provider' => \get_class($provider), 'username' => $refreshedUser->getUsername()];
  154.                     foreach ($token->getRoles() as $role) {
  155.                         if ($role instanceof SwitchUserRole) {
  156.                             $context['impersonator_username'] = $role->getSource()->getUsername();
  157.                             break;
  158.                         }
  159.                     }
  160.                     $this->logger->debug('User was reloaded from a user provider.'$context);
  161.                 }
  162.                 return $token;
  163.             } catch (UnsupportedUserException $e) {
  164.                 // let's try the next user provider
  165.             } catch (UsernameNotFoundException $e) {
  166.                 if (null !== $this->logger) {
  167.                     $this->logger->warning('Username could not be found in the selected user provider.', ['username' => $e->getUsername(), 'provider' => \get_class($provider)]);
  168.                 }
  169.                 $userNotFoundByProvider true;
  170.             }
  171.         }
  172.         if ($userDeauthenticated) {
  173.             if (null !== $this->logger) {
  174.                 $this->logger->debug('Token was deauthenticated after trying to refresh it.');
  175.             }
  176.             return null;
  177.         }
  178.         if ($userNotFoundByProvider) {
  179.             return null;
  180.         }
  181.         throw new \RuntimeException(sprintf('There is no user provider for user "%s".', \get_class($user)));
  182.     }
  183.     private function safelyUnserialize($serializedToken) {
  184.         $e $token null;
  185.         $prevUnserializeHandler ini_set('unserialize_callback_func'__CLASS__ '::handleUnserializeCallback');
  186.         $prevErrorHandler set_error_handler(function ($type$msg$file$line$context = []) use (&$prevErrorHandler) {
  187.             if (__FILE__ === $file) {
  188.                 throw new \ErrorException($msg0x37313bc$type$file$line);
  189.             }
  190.             return $prevErrorHandler $prevErrorHandler($type$msg$file$line$context) : false;
  191.         });
  192.         try {
  193.             $token unserialize($serializedToken);
  194.         } catch (\Throwable $e) {
  195.             
  196.         }
  197.         restore_error_handler();
  198.         ini_set('unserialize_callback_func'$prevUnserializeHandler);
  199.         if ($e) {
  200.             if (!$e instanceof \ErrorException || 0x37313bc !== $e->getCode()) {
  201.                 throw $e;
  202.             }
  203.             if ($this->logger) {
  204.                 $this->logger->warning('Failed to unserialize the security token from the session.', ['key' => $this->sessionKey'received' => $serializedToken'exception' => $e]);
  205.             }
  206.         }
  207.         return $token;
  208.     }
  209.     /**
  210.      * @internal
  211.      */
  212.     public static function handleUnserializeCallback($class) {
  213.         throw new \ErrorException('Class not found: ' $class0x37313bc);
  214.     }
  215. }