vendor/symfony/security/Core/Authentication/Provider/UserAuthenticationProvider.php line 71

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\TokenInterface;
  15. use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
  16. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  17. use Symfony\Component\Security\Core\Exception\AuthenticationServiceException;
  18. use Symfony\Component\Security\Core\Exception\BadCredentialsException;
  19. use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
  20. use Symfony\Component\Security\Core\Role\SwitchUserRole;
  21. use Symfony\Component\Security\Core\User\UserCheckerInterface;
  22. use Symfony\Component\Security\Core\User\UserInterface;
  24. /**
  25.  * UserProviderInterface retrieves users for UsernamePasswordToken tokens.
  26.  *
  27.  * @author Fabien Potencier <fabien@symfony.com>
  28.  */
  29. abstract class UserAuthenticationProvider implements AuthenticationProviderInterface
  30. {
  31.     private $hideUserNotFoundExceptions;
  32.     private $userChecker;
  33.     private $providerKey;
  35.     /**
  36.      * @param UserCheckerInterface $userChecker                An UserCheckerInterface interface
  37.      * @param string               $providerKey                A provider key
  38.      * @param bool                 $hideUserNotFoundExceptions Whether to hide user not found exception or not
  39.      *
  40.      * @throws \InvalidArgumentException
  41.      */
  42.     public function __construct(UserCheckerInterface $userChecker, $providerKey, $hideUserNotFoundExceptions = true)
  43.     {
  44.         if (empty($providerKey)) {
  45.             throw new \InvalidArgumentException('$providerKey must not be empty.');
  46.         }
  48.         $this->userChecker = $userChecker;
  49.         $this->providerKey = $providerKey;
  50.         $this->hideUserNotFoundExceptions = $hideUserNotFoundExceptions;
  51.     }
  53.     /**
  54.      * {@inheritdoc}
  55.      */
  56.     public function authenticate(TokenInterface $token)
  57.     {
  58.         if (!$this->supports($token)) {
  59.             throw new AuthenticationException('The token is not supported by this authentication provider.');
  60.         }
  62.         $username = $token->getUsername();
  63.         if ('' === $username || null === $username) {
  64.             $username = AuthenticationProviderInterface::USERNAME_NONE_PROVIDED;
  65.         }
  67.         try {
  68.             $user = $this->retrieveUser($username, $token);
  69.         } catch (UsernameNotFoundException $e) {
  70.             if ($this->hideUserNotFoundExceptions) {
  71.                 throw new BadCredentialsException('Bad credentials.', 0, $e);
  72.             }
  73.             $e->setUsername($username);
  75.             throw $e;
  76.         }
  78.         if (!$user instanceof UserInterface) {
  79.             throw new AuthenticationServiceException('retrieveUser() must return a UserInterface.');
  80.         }
  82.         try {
  83.             $this->userChecker->checkPreAuth($user);
  84.             $this->checkAuthentication($user, $token);
  85.             $this->userChecker->checkPostAuth($user);
  86.         } catch (BadCredentialsException $e) {
  87.             if ($this->hideUserNotFoundExceptions) {
  88.                 throw new BadCredentialsException('Bad credentials.', 0, $e);
  89.             }
  91.             throw $e;
  92.         }
  94.         $authenticatedToken = new UsernamePasswordToken($user, $token->getCredentials(), $this->providerKey, $this->getRoles($user, $token));
  95.         $authenticatedToken->setAttributes($token->getAttributes());
  97.         return $authenticatedToken;
  98.     }
  100.     /**
  101.      * {@inheritdoc}
  102.      */
  103.     public function supports(TokenInterface $token)
  104.     {
  105.         return $token instanceof UsernamePasswordToken && $this->providerKey === $token->getProviderKey();
  106.     }
  108.     /**
  109.      * Retrieves roles from user and appends SwitchUserRole if original token contained one.
  110.      *
  111.      * @return array The user roles
  112.      */
  113.     private function getRoles(UserInterface $user, TokenInterface $token)
  114.     {
  115.         $roles = $user->getRoles();
  117.         foreach ($token->getRoles() 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.      * @param UsernamePasswordToken $token    The Token
  133.      *
  134.      * @return UserInterface The user
  135.      *
  136.      * @throws AuthenticationException if the credentials could not be validated
  137.      */
  138.     abstract protected function retrieveUser($username, UsernamePasswordToken $token);
  140.     /**
  141.      * Does additional checks on the user and token (like validating the
  142.      * credentials).
  143.      *
  144.      * @throws AuthenticationException if the credentials could not be validated
  145.      */
  146.     abstract protected function checkAuthentication(UserInterface $user, UsernamePasswordToken $token);
  147. }