vendor/symfony/security-http/RememberMe/AbstractRememberMeHandler.php line 63

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\RequestStack;
  17. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Component\Security\Core\User\UserProviderInterface;
  21. /**
  22.  * @author Wouter de Jong <wouter@wouterj.nl>
  23.  */
  24. abstract class AbstractRememberMeHandler implements RememberMeHandlerInterface
  25. {
  26.     private $userProvider;
  27.     protected $requestStack;
  28.     protected $options;
  29.     protected $logger;
  31.     public function __construct(UserProviderInterface $userProvider, RequestStack $requestStack, array $options = [], LoggerInterface $logger = null)
  32.     {
  33.         $this->userProvider = $userProvider;
  34.         $this->requestStack = $requestStack;
  35.         $this->options = $options + [
  36.             'name' => 'REMEMBERME',
  37.             'lifetime' => 31536000,
  38.             'path' => '/',
  39.             'domain' => null,
  40.             'secure' => false,
  41.             'httponly' => true,
  42.             'samesite' => null,
  43.             'always_remember_me' => false,
  44.             'remember_me_parameter' => '_remember_me',
  45.         ];
  46.         $this->logger = $logger;
  47.     }
  49.     /**
  50.      * Checks if the RememberMeDetails is a valid cookie to login the given User.
  51.      *
  52.      * This method should also:
  53.      * - Create a new remember-me cookie to be sent with the response (using {@see createCookie()});
  54.      * - If you store the token somewhere else (e.g. in a database), invalidate the stored token.
  55.      *
  56.      * @throws AuthenticationException throw this exception if the remember me details are not accepted
  57.      */
  58.     abstract protected function processRememberMe(RememberMeDetails $rememberMeDetails, UserInterface $user): void;
  60.     /**
  61.      * {@inheritdoc}
  62.      */
  63.     public function consumeRememberMeCookie(RememberMeDetails $rememberMeDetails): UserInterface
  64.     {
  65.         try {
  66.             // @deprecated since Symfony 5.3, change to $this->userProvider->loadUserByIdentifier() in 6.0
  67.             $method = 'loadUserByIdentifier';
  68.             if (!method_exists($this->userProvider, 'loadUserByIdentifier')) {
  69.                 trigger_deprecation('symfony/security-core', '5.3', 'Not implementing method "loadUserByIdentifier()" in user provider "%s" is deprecated. This method will replace "loadUserByUsername()" in Symfony 6.0.', get_debug_type($this->userProvider));
  71.                 $method = 'loadUserByUsername';
  72.             }
  74.             $user = $this->userProvider->$method($rememberMeDetails->getUserIdentifier());
  75.         } catch (AuthenticationException $e) {
  76.             throw $e;
  77.         }
  79.         if (!$user instanceof UserInterface) {
  80.             throw new \LogicException(sprintf('The UserProviderInterface implementation must return an instance of UserInterface, but returned "%s".', get_debug_type($user)));
  81.         }
  83.         $this->processRememberMe($rememberMeDetails, $user);
  85.         if (null !== $this->logger) {
  86.             $this->logger->info('Remember-me cookie accepted.');
  87.         }
  89.         return $user;
  90.     }
  92.     /**
  93.      * {@inheritdoc}
  94.      */
  95.     public function clearRememberMeCookie(): void
  96.     {
  97.         if (null !== $this->logger) {
  98.             $this->logger->debug('Clearing remember-me cookie.', ['name' => $this->options['name']]);
  99.         }
  101.         $this->createCookie(null);
  102.     }
  104.     /**
  105.      * Creates the remember-me cookie using the correct configuration.
  106.      *
  107.      * @param RememberMeDetails|null $rememberMeDetails The details for the cookie, or null to clear the remember-me cookie
  108.      */
  109.     protected function createCookie(?RememberMeDetails $rememberMeDetails)
  110.     {
  111.         $request = $this->requestStack->getMainRequest();
  112.         if (!$request) {
  113.             throw new \LogicException('Cannot create the remember-me cookie; no master request available.');
  114.         }
  116.         // the ResponseListener configures the cookie saved in this attribute on the final response object
  117.         $request->attributes->set(ResponseListener::COOKIE_ATTR_NAME, new Cookie(
  118.             $this->options['name'],
  119.             $rememberMeDetails ? $rememberMeDetails->toString() : null,
  120.             $rememberMeDetails ? $rememberMeDetails->getExpires() : 1,
  121.             $this->options['path'],
  122.             $this->options['domain'],
  123.             $this->options['secure'] ?? $request->isSecure(),
  124.             $this->options['httponly'],
  125.             false,
  126.             $this->options['samesite']
  127.         ));
  128.     }
  129. }