vendor/symfony/security-core/Authentication/Provider/UserAuthenticationProvider.php line 53

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\Core\Authentication\Provider;
  14. use Symfony\Component\Security\Core\Authentication\Token\SwitchUserToken;
  15. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  16. use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
  17. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  18. use Symfony\Component\Security\Core\Exception\AuthenticationServiceException;
  19. use Symfony\Component\Security\Core\Exception\BadCredentialsException;
  20. use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
  21. use Symfony\Component\Security\Core\Role\SwitchUserRole;
  22. use Symfony\Component\Security\Core\User\UserCheckerInterface;
  23. use Symfony\Component\Security\Core\User\UserInterface;
  25. /**
  26.  * UserProviderInterface retrieves users for UsernamePasswordToken tokens.
  27.  *
  28.  * @author Fabien Potencier <fabien@symfony.com>
  29.  */
  30. abstract class UserAuthenticationProvider implements AuthenticationProviderInterface
  31. {
  32.     private $hideUserNotFoundExceptions;
  33.     private $userChecker;
  34.     private $providerKey;
  36.     /**
  37.      * @throws \InvalidArgumentException
  38.      */
  39.     public function __construct(UserCheckerInterface $userChecker, string $providerKey, bool $hideUserNotFoundExceptions = true)
  40.     {
  41.         if (empty($providerKey)) {
  42.             throw new \InvalidArgumentException('$providerKey must not be empty.');
  43.         }
  45.         $this->userChecker = $userChecker;
  46.         $this->providerKey = $providerKey;
  47.         $this->hideUserNotFoundExceptions = $hideUserNotFoundExceptions;
  48.     }
  50.     /**
  51.      * {@inheritdoc}
  52.      */
  53.     public function authenticate(TokenInterface $token)
  54.     {
  55.         if (!$this->supports($token)) {
  56.             throw new AuthenticationException('The token is not supported by this authentication provider.');
  57.         }
  59.         $username = $token->getUsername();
  60.         if ('' === $username || null === $username) {
  61.             $username = AuthenticationProviderInterface::USERNAME_NONE_PROVIDED;
  62.         }
  64.         try {
  65.             $user = $this->retrieveUser($username, $token);
  66.         } catch (UsernameNotFoundException $e) {
  67.             if ($this->hideUserNotFoundExceptions) {
  68.                 throw new BadCredentialsException('Bad credentials.', 0, $e);
  69.             }
  70.             $e->setUsername($username);
  72.             throw $e;
  73.         }
  75.         if (!$user instanceof UserInterface) {
  76.             throw new AuthenticationServiceException('retrieveUser() must return a UserInterface.');
  77.         }
  79.         try {
  80.             $this->userChecker->checkPreAuth($user);
  81.             $this->checkAuthentication($user, $token);
  82.             $this->userChecker->checkPostAuth($user);
  83.         } catch (BadCredentialsException $e) {
  84.             if ($this->hideUserNotFoundExceptions) {
  85.                 throw new BadCredentialsException('Bad credentials.', 0, $e);
  86.             }
  88.             throw $e;
  89.         }
  91.         if ($token instanceof SwitchUserToken) {
  92.             $authenticatedToken = new SwitchUserToken($user, $token->getCredentials(), $this->providerKey, $this->getRoles($user, $token), $token->getOriginalToken());
  93.         } else {
  94.             $authenticatedToken = new UsernamePasswordToken($user, $token->getCredentials(), $this->providerKey, $this->getRoles($user, $token));
  95.         }
  97.         $authenticatedToken->setAttributes($token->getAttributes());
  99.         return $authenticatedToken;
  100.     }
  102.     /**
  103.      * {@inheritdoc}
  104.      */
  105.     public function supports(TokenInterface $token)
  106.     {
  107.         return $token instanceof UsernamePasswordToken && $this->providerKey === $token->getProviderKey();
  108.     }
  110.     /**
  111.      * Retrieves roles from user and appends SwitchUserRole if original token contained one.
  112.      */
  113.     private function getRoles(UserInterface $user, TokenInterface $token): array
  114.     {
  115.         $roles = $user->getRoles();
  117.         foreach ($token->getRoles(false) as $role) {
  118.             if ($role instanceof SwitchUserRole) {
  119.                 $roles[] = $role;
  121.                 break;
  122.             }
  123.         }
  125.         return $roles;
  126.     }
  128.     /**
  129.      * Retrieves the user from an implementation-specific location.
  130.      *
  131.      * @param string $username The username to retrieve
  132.      *
  133.      * @return UserInterface The user
  134.      *
  135.      * @throws AuthenticationException if the credentials could not be validated
  136.      */
  137.     abstract protected function retrieveUser($username, UsernamePasswordToken $token);
  139.     /**
  140.      * Does additional checks on the user and token (like validating the
  141.      * credentials).
  142.      *
  143.      * @throws AuthenticationException if the credentials could not be validated
  144.      */
  145.     abstract protected function checkAuthentication(UserInterface $user, UsernamePasswordToken $token);
  146. }