vendor/symfony/security-http/RememberMe/AbstractRememberMeServices.php line 29

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\RememberMe;
  14. use Psr\Log\LoggerInterface;
  15. use Symfony\Component\HttpFoundation\Cookie;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use Symfony\Component\Security\Core\Authentication\Token\RememberMeToken;
  19. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  20. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  21. use Symfony\Component\Security\Core\Exception\CookieTheftException;
  22. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  23. use Symfony\Component\Security\Core\Exception\UserNotFoundException;
  24. use Symfony\Component\Security\Core\User\UserInterface;
  25. use Symfony\Component\Security\Core\User\UserProviderInterface;
  26. use Symfony\Component\Security\Http\Logout\LogoutHandlerInterface;
  27. use Symfony\Component\Security\Http\ParameterBagUtils;
  29. trigger_deprecation('symfony/security-http', '5.4', 'The "%s" class is deprecated, use "%s" instead.', AbstractRememberMeServices::class, AbstractRememberMeHandler::class);
  31. /**
  32.  * Base class implementing the RememberMeServicesInterface.
  33.  *
  34.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  35.  *
  36.  * @deprecated since Symfony 5.4, use {@see AbstractRememberMeHandler} instead
  37.  */
  38. abstract class AbstractRememberMeServices implements RememberMeServicesInterface, LogoutHandlerInterface
  39. {
  40.     public const COOKIE_DELIMITER = ':';
  42.     protected $logger;
  43.     protected $options = [
  44.         'secure' => false,
  45.         'httponly' => true,
  46.         'samesite' => null,
  47.         'path' => null,
  48.         'domain' => null,
  49.     ];
  50.     private $firewallName;
  51.     private $secret;
  52.     private $userProviders;
  54.     /**
  55.      * @throws \InvalidArgumentException
  56.      */
  57.     public function __construct(iterable $userProviders, string $secret, string $firewallName, array $options = [], ?LoggerInterface $logger = null)
  58.     {
  59.         if (empty($secret)) {
  60.             throw new \InvalidArgumentException('$secret must not be empty.');
  61.         }
  62.         if ('' === $firewallName) {
  63.             throw new \InvalidArgumentException('$firewallName must not be empty.');
  64.         }
  65.         if (!\is_array($userProviders) && !$userProviders instanceof \Countable) {
  66.             $userProviders = iterator_to_array($userProviders, false);
  67.         }
  68.         if (0 === \count($userProviders)) {
  69.             throw new \InvalidArgumentException('You must provide at least one user provider.');
  70.         }
  72.         $this->userProviders = $userProviders;
  73.         $this->secret = $secret;
  74.         $this->firewallName = $firewallName;
  75.         $this->options = array_merge($this->options, $options);
  76.         $this->logger = $logger;
  77.     }
  79.     /**
  80.      * Returns the parameter that is used for checking whether remember-me
  81.      * services have been requested.
  82.      *
  83.      * @return string
  84.      */
  85.     public function getRememberMeParameter()
  86.     {
  87.         return $this->options['remember_me_parameter'];
  88.     }
  90.     /**
  91.      * @return string
  92.      */
  93.     public function getSecret()
  94.     {
  95.         return $this->secret;
  96.     }
  98.     /**
  99.      * Implementation of RememberMeServicesInterface. Detects whether a remember-me
  100.      * cookie was set, decodes it, and hands it to subclasses for further processing.
  101.      *
  102.      * @throws CookieTheftException
  103.      * @throws \RuntimeException
  104.      */
  105.     final public function autoLogin(Request $request): ?TokenInterface
  106.     {
  107.         if (($cookie = $request->attributes->get(self::COOKIE_ATTR_NAME)) && null === $cookie->getValue()) {
  108.             return null;
  109.         }
  111.         if (null === $cookie = $request->cookies->get($this->options['name'])) {
  112.             return null;
  113.         }
  115.         if (null !== $this->logger) {
  116.             $this->logger->debug('Remember-me cookie detected.');
  117.         }
  119.         $cookieParts = $this->decodeCookie($cookie);
  121.         try {
  122.             $user = $this->processAutoLoginCookie($cookieParts, $request);
  124.             if (!$user instanceof UserInterface) {
  125.                 throw new \RuntimeException('processAutoLoginCookie() must return a UserInterface implementation.');
  126.             }
  128.             if (null !== $this->logger) {
  129.                 $this->logger->info('Remember-me cookie accepted.');
  130.             }
  132.             return new RememberMeToken($user, $this->firewallName, $this->secret);
  133.         } catch (CookieTheftException $e) {
  134.             $this->loginFail($request, $e);
  136.             throw $e;
  137.         } catch (UserNotFoundException $e) {
  138.             if (null !== $this->logger) {
  139.                 $this->logger->info('User for remember-me cookie not found.', ['exception' => $e]);
  140.             }
  142.             $this->loginFail($request, $e);
  143.         } catch (UnsupportedUserException $e) {
  144.             if (null !== $this->logger) {
  145.                 $this->logger->warning('User class for remember-me cookie not supported.', ['exception' => $e]);
  146.             }
  148.             $this->loginFail($request, $e);
  149.         } catch (AuthenticationException $e) {
  150.             if (null !== $this->logger) {
  151.                 $this->logger->debug('Remember-Me authentication failed.', ['exception' => $e]);
  152.             }
  154.             $this->loginFail($request, $e);
  155.         } catch (\Exception $e) {
  156.             $this->loginFail($request, $e);
  158.             throw $e;
  159.         }
  161.         return null;
  162.     }
  164.     /**
  165.      * Implementation for LogoutHandlerInterface. Deletes the cookie.
  166.      */
  167.     public function logout(Request $request, Response $response, TokenInterface $token)
  168.     {
  169.         $this->cancelCookie($request);
  170.     }
  172.     /**
  173.      * Implementation for RememberMeServicesInterface. Deletes the cookie when
  174.      * an attempted authentication fails.
  175.      */
  176.     final public function loginFail(Request $request, ?\Exception $exception = null)
  177.     {
  178.         $this->cancelCookie($request);
  179.         $this->onLoginFail($request, $exception);
  180.     }
  182.     /**
  183.      * Implementation for RememberMeServicesInterface. This is called when an
  184.      * authentication is successful.
  185.      */
  186.     final public function loginSuccess(Request $request, Response $response, TokenInterface $token)
  187.     {
  188.         // Make sure any old remember-me cookies are cancelled
  189.         $this->cancelCookie($request);
  191.         if (!$token->getUser() instanceof UserInterface) {
  192.             if (null !== $this->logger) {
  193.                 $this->logger->debug('Remember-me ignores token since it does not contain a UserInterface implementation.');
  194.             }
  196.             return;
  197.         }
  199.         if (!$this->isRememberMeRequested($request)) {
  200.             if (null !== $this->logger) {
  201.                 $this->logger->debug('Remember-me was not requested.');
  202.             }
  204.             return;
  205.         }
  207.         if (null !== $this->logger) {
  208.             $this->logger->debug('Remember-me was requested; setting cookie.');
  209.         }
  211.         // Remove attribute from request that sets a NULL cookie.
  212.         // It was set by $this->cancelCookie()
  213.         // (cancelCookie does other things too for some RememberMeServices
  214.         // so we should still call it at the start of this method)
  215.         $request->attributes->remove(self::COOKIE_ATTR_NAME);
  217.         $this->onLoginSuccess($request, $response, $token);
  218.     }
  220.     /**
  221.      * Subclasses should validate the cookie and do any additional processing
  222.      * that is required. This is called from autoLogin().
  223.      *
  224.      * @return UserInterface
  225.      */
  226.     abstract protected function processAutoLoginCookie(array $cookieParts, Request $request);
  228.     protected function onLoginFail(Request $request, ?\Exception $exception = null)
  229.     {
  230.     }
  232.     /**
  233.      * This is called after a user has been logged in successfully, and has
  234.      * requested remember-me capabilities. The implementation usually sets a
  235.      * cookie and possibly stores a persistent record of it.
  236.      */
  237.     abstract protected function onLoginSuccess(Request $request, Response $response, TokenInterface $token);
  239.     final protected function getUserProvider(string $class): UserProviderInterface
  240.     {
  241.         foreach ($this->userProviders as $provider) {
  242.             if ($provider->supportsClass($class)) {
  243.                 return $provider;
  244.             }
  245.         }
  247.         throw new UnsupportedUserException(sprintf('There is no user provider for user "%s". Shouldn\'t the "supportsClass()" method of your user provider return true for this classname?', $class));
  248.     }
  250.     /**
  251.      * Decodes the raw cookie value.
  252.      *
  253.      * @return array
  254.      */
  255.     protected function decodeCookie(string $rawCookie)
  256.     {
  257.         return explode(self::COOKIE_DELIMITER, base64_decode($rawCookie));
  258.     }
  260.     /**
  261.      * Encodes the cookie parts.
  262.      *
  263.      * @return string
  264.      *
  265.      * @throws \InvalidArgumentException When $cookieParts contain the cookie delimiter. Extending class should either remove or escape it.
  266.      */
  267.     protected function encodeCookie(array $cookieParts)
  268.     {
  269.         foreach ($cookieParts as $cookiePart) {
  270.             if (str_contains($cookiePart, self::COOKIE_DELIMITER)) {
  271.                 throw new \InvalidArgumentException(sprintf('$cookieParts should not contain the cookie delimiter "%s".', self::COOKIE_DELIMITER));
  272.             }
  273.         }
  275.         return base64_encode(implode(self::COOKIE_DELIMITER, $cookieParts));
  276.     }
  278.     /**
  279.      * Deletes the remember-me cookie.
  280.      */
  281.     protected function cancelCookie(Request $request)
  282.     {
  283.         if (null !== $this->logger) {
  284.             $this->logger->debug('Clearing remember-me cookie.', ['name' => $this->options['name']]);
  285.         }
  287.         $request->attributes->set(self::COOKIE_ATTR_NAME, new Cookie($this->options['name'], null, 1, $this->options['path'], $this->options['domain'], $this->options['secure'] ?? $request->isSecure(), $this->options['httponly'], false, $this->options['samesite']));
  288.     }
  290.     /**
  291.      * Checks whether remember-me capabilities were requested.
  292.      *
  293.      * @return bool
  294.      */
  295.     protected function isRememberMeRequested(Request $request)
  296.     {
  297.         if (true === $this->options['always_remember_me']) {
  298.             return true;
  299.         }
  301.         $parameter = ParameterBagUtils::getRequestParameterValue($request, $this->options['remember_me_parameter']);
  303.         if (null === $parameter && null !== $this->logger) {
  304.             $this->logger->debug('Did not send remember-me cookie.', ['parameter' => $this->options['remember_me_parameter']]);
  305.         }
  307.         return 'true' === $parameter || 'on' === $parameter || '1' === $parameter || 'yes' === $parameter || true === $parameter;
  308.     }
  309. }