vendor/symfony/security-http/Firewall/SwitchUserListener.php line 41

  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\RedirectResponse;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpKernel\Event\RequestEvent;
  18. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  19. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  20. use Symfony\Component\Security\Core\Authentication\Token\SwitchUserToken;
  21. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  22. use Symfony\Component\Security\Core\Authorization\AccessDecisionManagerInterface;
  23. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  24. use Symfony\Component\Security\Core\Exception\AuthenticationCredentialsNotFoundException;
  25. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  26. use Symfony\Component\Security\Core\User\UserCheckerInterface;
  27. use Symfony\Component\Security\Core\User\UserInterface;
  28. use Symfony\Component\Security\Core\User\UserProviderInterface;
  29. use Symfony\Component\Security\Http\Event\SwitchUserEvent;
  30. use Symfony\Component\Security\Http\SecurityEvents;
  31. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  33. /**
  34.  * SwitchUserListener allows a user to impersonate another one temporarily
  35.  * (like the Unix su command).
  36.  *
  37.  * @author Fabien Potencier <fabien@symfony.com>
  38.  *
  39.  * @final
  40.  */
  41. class SwitchUserListener extends AbstractListener
  42. {
  43.     public const EXIT_VALUE = '_exit';
  45.     private TokenStorageInterface $tokenStorage;
  46.     private UserProviderInterface $provider;
  47.     private UserCheckerInterface $userChecker;
  48.     private string $firewallName;
  49.     private AccessDecisionManagerInterface $accessDecisionManager;
  50.     private string $usernameParameter;
  51.     private string $role;
  52.     private ?LoggerInterface $logger;
  53.     private ?EventDispatcherInterface $dispatcher;
  54.     private bool $stateless;
  55.     private ?UrlGeneratorInterface $urlGenerator;
  56.     private ?string $targetRoute;
  58.     public function __construct(TokenStorageInterface $tokenStorage, UserProviderInterface $provider, UserCheckerInterface $userChecker, string $firewallName, AccessDecisionManagerInterface $accessDecisionManager, LoggerInterface $logger = null, string $usernameParameter = '_switch_user', string $role = 'ROLE_ALLOWED_TO_SWITCH', EventDispatcherInterface $dispatcher = null, bool $stateless = false, UrlGeneratorInterface $urlGenerator = null, string $targetRoute = null)
  59.     {
  60.         if ('' === $firewallName) {
  61.             throw new \InvalidArgumentException('$firewallName must not be empty.');
  62.         }
  64.         $this->tokenStorage = $tokenStorage;
  65.         $this->provider = $provider;
  66.         $this->userChecker = $userChecker;
  67.         $this->firewallName = $firewallName;
  68.         $this->accessDecisionManager = $accessDecisionManager;
  69.         $this->usernameParameter = $usernameParameter;
  70.         $this->role = $role;
  71.         $this->logger = $logger;
  72.         $this->dispatcher = $dispatcher;
  73.         $this->stateless = $stateless;
  74.         $this->urlGenerator = $urlGenerator;
  75.         $this->targetRoute = $targetRoute;
  76.     }
  78.     public function supports(Request $request): ?bool
  79.     {
  80.         // usernames can be falsy
  81.         $username = $request->get($this->usernameParameter);
  83.         if (null === $username || '' === $username) {
  84.             $username = $request->headers->get($this->usernameParameter);
  85.         }
  87.         // if it's still "empty", nothing to do.
  88.         if (null === $username || '' === $username) {
  89.             return false;
  90.         }
  92.         $request->attributes->set('_switch_user_username', $username);
  94.         return true;
  95.     }
  97.     /**
  98.      * Handles the switch to another user.
  99.      *
  100.      * @throws \LogicException if switching to a user failed
  101.      */
  102.     public function authenticate(RequestEvent $event)
  103.     {
  104.         $request = $event->getRequest();
  106.         $username = $request->attributes->get('_switch_user_username');
  107.         $request->attributes->remove('_switch_user_username');
  109.         if (null === $this->tokenStorage->getToken()) {
  110.             throw new AuthenticationCredentialsNotFoundException('Could not find original Token object.');
  111.         }
  113.         if (self::EXIT_VALUE === $username) {
  114.             $this->tokenStorage->setToken($this->attemptExitUser($request));
  115.         } else {
  116.             try {
  117.                 $this->tokenStorage->setToken($this->attemptSwitchUser($request, $username));
  118.             } catch (AuthenticationException $e) {
  119.                 // Generate 403 in any conditions to prevent user enumeration vulnerabilities
  120.                 throw new AccessDeniedException('Switch User failed: '.$e->getMessage(), $e);
  121.             }
  122.         }
  124.         if (!$this->stateless) {
  125.             $request->query->remove($this->usernameParameter);
  126.             $request->server->set('QUERY_STRING', http_build_query($request->query->all(), '', '&'));
  127.             $response = new RedirectResponse($this->urlGenerator && $this->targetRoute ? $this->urlGenerator->generate($this->targetRoute) : $request->getUri(), 302);
  129.             $event->setResponse($response);
  130.         }
  131.     }
  133.     /**
  134.      * Attempts to switch to another user and returns the new token if successfully switched.
  135.      *
  136.      * @throws \LogicException
  137.      * @throws AccessDeniedException
  138.      */
  139.     private function attemptSwitchUser(Request $request, string $username): ?TokenInterface
  140.     {
  141.         $token = $this->tokenStorage->getToken();
  142.         $originalToken = $this->getOriginalToken($token);
  144.         if (null !== $originalToken) {
  145.             if ($token->getUserIdentifier() === $username) {
  146.                 return $token;
  147.             }
  149.             // User already switched, exit before seamlessly switching to another user
  150.             $token = $this->attemptExitUser($request);
  151.         }
  153.         $currentUsername = $token->getUserIdentifier();
  154.         $nonExistentUsername = '_'.md5(random_bytes(8).$username);
  156.         // To protect against user enumeration via timing measurements
  157.         // we always load both successfully and unsuccessfully
  158.         try {
  159.             $user = $this->provider->loadUserByIdentifier($username);
  161.             try {
  162.                 $this->provider->loadUserByIdentifier($nonExistentUsername);
  163.             } catch (\Exception) {
  164.             }
  165.         } catch (AuthenticationException $e) {
  166.             $this->provider->loadUserByIdentifier($currentUsername);
  168.             throw $e;
  169.         }
  171.         if (false === $this->accessDecisionManager->decide($token, [$this->role], $user)) {
  172.             $exception = new AccessDeniedException();
  173.             $exception->setAttributes($this->role);
  175.             throw $exception;
  176.         }
  178.         $this->logger?->info('Attempting to switch to user.', ['username' => $username]);
  180.         $this->userChecker->checkPostAuth($user);
  182.         $roles = $user->getRoles();
  183.         $roles[] = 'ROLE_PREVIOUS_ADMIN';
  184.         $originatedFromUri = str_replace('/&', '/?', preg_replace('#[&?]'.$this->usernameParameter.'=[^&]*#', '', $request->getRequestUri()));
  185.         $token = new SwitchUserToken($user, $this->firewallName, $roles, $token, $originatedFromUri);
  187.         if (null !== $this->dispatcher) {
  188.             $switchEvent = new SwitchUserEvent($request, $token->getUser(), $token);
  189.             $this->dispatcher->dispatch($switchEvent, SecurityEvents::SWITCH_USER);
  190.             // use the token from the event in case any listeners have replaced it.
  191.             $token = $switchEvent->getToken();
  192.         }
  194.         return $token;
  195.     }
  197.     /**
  198.      * Attempts to exit from an already switched user and returns the original token.
  199.      *
  200.      * @throws AuthenticationCredentialsNotFoundException
  201.      */
  202.     private function attemptExitUser(Request $request): TokenInterface
  203.     {
  204.         if (null === ($currentToken = $this->tokenStorage->getToken()) || null === $original = $this->getOriginalToken($currentToken)) {
  205.             throw new AuthenticationCredentialsNotFoundException('Could not find original Token object.');
  206.         }
  208.         if (null !== $this->dispatcher && $original->getUser() instanceof UserInterface) {
  209.             $user = $this->provider->refreshUser($original->getUser());
  210.             $original->setUser($user);
  211.             $switchEvent = new SwitchUserEvent($request, $user, $original);
  212.             $this->dispatcher->dispatch($switchEvent, SecurityEvents::SWITCH_USER);
  213.             $original = $switchEvent->getToken();
  214.         }
  216.         return $original;
  217.     }
  219.     private function getOriginalToken(TokenInterface $token): ?TokenInterface
  220.     {
  221.         if ($token instanceof SwitchUserToken) {
  222.             return $token->getOriginalToken();
  223.         }
  225.         return null;
  226.     }
  227. }