vendor/symfony/security-core/Authentication/Token/AbstractToken.php line 104

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\Token;
  14. use Symfony\Component\Security\Core\Role\Role;
  15. use Symfony\Component\Security\Core\User\AdvancedUserInterface;
  16. use Symfony\Component\Security\Core\User\EquatableInterface;
  17. use Symfony\Component\Security\Core\User\UserInterface;
  19. /**
  20.  * Base class for Token instances.
  21.  *
  22.  * @author Fabien Potencier <fabien@symfony.com>
  23.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  24.  */
  25. abstract class AbstractToken implements TokenInterface
  26. {
  27.     private $user;
  28.     private $roles = [];
  29.     private $roleNames = [];
  30.     private $authenticated = false;
  31.     private $attributes = [];
  33.     /**
  34.      * @param string[] $roles An array of roles
  35.      *
  36.      * @throws \InvalidArgumentException
  37.      */
  38.     public function __construct(array $roles = [])
  39.     {
  40.         foreach ($roles as $role) {
  41.             if (\is_string($role)) {
  42.                 $role = new Role($role, false);
  43.             } elseif (!$role instanceof Role) {
  44.                 throw new \InvalidArgumentException(sprintf('$roles must be an array of strings, but got "%s".', \gettype($role)));
  45.             }
  47.             $this->roles[] = $role;
  48.             $this->roleNames[] = (string) $role;
  49.         }
  50.     }
  52.     public function getRoleNames(): array
  53.     {
  54.         return $this->roleNames;
  55.     }
  57.     /**
  58.      * {@inheritdoc}
  59.      */
  60.     public function getRoles()
  61.     {
  62.         if (0 === \func_num_args() || func_get_arg(0)) {
  63.             @trigger_error(sprintf('The %s() method is deprecated since Symfony 4.3. Use the getRoleNames() method instead.', __METHOD__), E_USER_DEPRECATED);
  64.         }
  66.         return $this->roles;
  67.     }
  69.     /**
  70.      * {@inheritdoc}
  71.      */
  72.     public function getUsername()
  73.     {
  74.         if ($this->user instanceof UserInterface) {
  75.             return $this->user->getUsername();
  76.         }
  78.         return (string) $this->user;
  79.     }
  81.     /**
  82.      * {@inheritdoc}
  83.      */
  84.     public function getUser()
  85.     {
  86.         return $this->user;
  87.     }
  89.     /**
  90.      * {@inheritdoc}
  91.      */
  92.     public function setUser($user)
  93.     {
  94.         if (!($user instanceof UserInterface || (\is_object($user) && method_exists($user, '__toString')) || \is_string($user))) {
  95.             throw new \InvalidArgumentException('$user must be an instanceof UserInterface, an object implementing a __toString method, or a primitive string.');
  96.         }
  98.         if (null === $this->user) {
  99.             $changed = false;
  100.         } elseif ($this->user instanceof UserInterface) {
  101.             if (!$user instanceof UserInterface) {
  102.                 $changed = true;
  103.             } else {
  104.                 $changed = $this->hasUserChanged($user);
  105.             }
  106.         } elseif ($user instanceof UserInterface) {
  107.             $changed = true;
  108.         } else {
  109.             $changed = (string) $this->user !== (string) $user;
  110.         }
  112.         if ($changed) {
  113.             $this->setAuthenticated(false);
  114.         }
  116.         $this->user = $user;
  117.     }
  119.     /**
  120.      * {@inheritdoc}
  121.      */
  122.     public function isAuthenticated()
  123.     {
  124.         return $this->authenticated;
  125.     }
  127.     /**
  128.      * {@inheritdoc}
  129.      */
  130.     public function setAuthenticated($authenticated)
  131.     {
  132.         $this->authenticated = (bool) $authenticated;
  133.     }
  135.     /**
  136.      * {@inheritdoc}
  137.      */
  138.     public function eraseCredentials()
  139.     {
  140.         if ($this->getUser() instanceof UserInterface) {
  141.             $this->getUser()->eraseCredentials();
  142.         }
  143.     }
  145.     /**
  146.      * Returns all the necessary state of the object for serialization purposes.
  147.      *
  148.      * There is no need to serialize any entry, they should be returned as-is.
  149.      * If you extend this method, keep in mind you MUST guarantee parent data is present in the state.
  150.      * Here is an example of how to extend this method:
  151.      * <code>
  152.      *     public function __serialize(): array
  153.      *     {
  154.      *         return [$this->childAttribute, parent::__serialize()];
  155.      *     }
  156.      * </code>
  157.      *
  158.      * @see __unserialize()
  159.      */
  160.     public function __serialize(): array
  161.     {
  162.         return [$this->user, $this->authenticated, $this->roles, $this->attributes, $this->roleNames];
  163.     }
  165.     /**
  166.      * @return string
  167.      *
  168.      * @final since Symfony 4.3, use __serialize() instead
  169.      *
  170.      * @internal since Symfony 4.3, use __serialize() instead
  171.      */
  172.     public function serialize()
  173.     {
  174.         $serialized = $this->__serialize();
  176.         if (null === $isCalledFromOverridingMethod = \func_num_args() ? func_get_arg(0) : null) {
  177.             $trace = debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT, 2);
  178.             $isCalledFromOverridingMethod = isset($trace[1]['function'], $trace[1]['object']) && 'serialize' === $trace[1]['function'] && $this === $trace[1]['object'];
  179.         }
  181.         return $isCalledFromOverridingMethod ? $serialized : serialize($serialized);
  182.     }
  184.     /**
  185.      * Restores the object state from an array given by __serialize().
  186.      *
  187.      * There is no need to unserialize any entry in $data, they are already ready-to-use.
  188.      * If you extend this method, keep in mind you MUST pass the parent data to its respective class.
  189.      * Here is an example of how to extend this method:
  190.      * <code>
  191.      *     public function __unserialize(array $data): void
  192.      *     {
  193.      *         [$this->childAttribute, $parentData] = $data;
  194.      *         parent::__unserialize($parentData);
  195.      *     }
  196.      * </code>
  197.      *
  198.      * @see __serialize()
  199.      */
  200.     public function __unserialize(array $data): void
  201.     {
  202.         [$this->user, $this->authenticated, $this->roles, $this->attributes] = $data;
  204.         // migration path to 4.3+
  205.         if (null === $this->roleNames = $data[4] ?? null) {
  206.             $this->roleNames = [];
  207.             foreach ($this->roles as $role) {
  208.                 $this->roleNames[] = (string) $role;
  209.             }
  210.         }
  211.     }
  213.     /**
  214.      * {@inheritdoc}
  215.      *
  216.      * @final since Symfony 4.3, use __unserialize() instead
  217.      *
  218.      * @internal since Symfony 4.3, use __unserialize() instead
  219.      */
  220.     public function unserialize($serialized)
  221.     {
  222.         $this->__unserialize(\is_array($serialized) ? $serialized : unserialize($serialized));
  223.     }
  225.     /**
  226.      * Returns the token attributes.
  227.      *
  228.      * @return array The token attributes
  229.      */
  230.     public function getAttributes()
  231.     {
  232.         return $this->attributes;
  233.     }
  235.     /**
  236.      * Sets the token attributes.
  237.      *
  238.      * @param array $attributes The token attributes
  239.      */
  240.     public function setAttributes(array $attributes)
  241.     {
  242.         $this->attributes = $attributes;
  243.     }
  245.     /**
  246.      * Returns true if the attribute exists.
  247.      *
  248.      * @param string $name The attribute name
  249.      *
  250.      * @return bool true if the attribute exists, false otherwise
  251.      */
  252.     public function hasAttribute($name)
  253.     {
  254.         return \array_key_exists($name, $this->attributes);
  255.     }
  257.     /**
  258.      * Returns an attribute value.
  259.      *
  260.      * @param string $name The attribute name
  261.      *
  262.      * @return mixed The attribute value
  263.      *
  264.      * @throws \InvalidArgumentException When attribute doesn't exist for this token
  265.      */
  266.     public function getAttribute($name)
  267.     {
  268.         if (!\array_key_exists($name, $this->attributes)) {
  269.             throw new \InvalidArgumentException(sprintf('This token has no "%s" attribute.', $name));
  270.         }
  272.         return $this->attributes[$name];
  273.     }
  275.     /**
  276.      * Sets an attribute.
  277.      *
  278.      * @param string $name  The attribute name
  279.      * @param mixed  $value The attribute value
  280.      */
  281.     public function setAttribute($name, $value)
  282.     {
  283.         $this->attributes[$name] = $value;
  284.     }
  286.     /**
  287.      * {@inheritdoc}
  288.      */
  289.     public function __toString()
  290.     {
  291.         $class = static::class;
  292.         $class = substr($class, strrpos($class, '\\') + 1);
  294.         $roles = [];
  295.         foreach ($this->roles as $role) {
  296.             $roles[] = $role->getRole();
  297.         }
  299.         return sprintf('%s(user="%s", authenticated=%s, roles="%s")', $class, $this->getUsername(), json_encode($this->authenticated), implode(', ', $roles));
  300.     }
  302.     private function hasUserChanged(UserInterface $user): bool
  303.     {
  304.         if (!($this->user instanceof UserInterface)) {
  305.             throw new \BadMethodCallException('Method "hasUserChanged" should be called when current user class is instance of "UserInterface".');
  306.         }
  308.         if ($this->user instanceof EquatableInterface) {
  309.             return !(bool) $this->user->isEqualTo($user);
  310.         }
  312.         if ($this->user->getPassword() !== $user->getPassword()) {
  313.             return true;
  314.         }
  316.         if ($this->user->getSalt() !== $user->getSalt()) {
  317.             return true;
  318.         }
  320.         $userRoles = array_map('strval', (array) $user->getRoles());
  322.         if ($this instanceof SwitchUserToken) {
  323.             $userRoles[] = 'ROLE_PREVIOUS_ADMIN';
  324.         }
  326.         if (\count($userRoles) !== \count($this->getRoleNames()) || \count($userRoles) !== \count(array_intersect($userRoles, $this->getRoleNames()))) {
  327.             return true;
  328.         }
  330.         if ($this->user->getUsername() !== $user->getUsername()) {
  331.             return true;
  332.         }
  334.         if ($this->user instanceof AdvancedUserInterface && $user instanceof AdvancedUserInterface) {
  335.             @trigger_error(sprintf('Checking for the AdvancedUserInterface in "%s()" is deprecated since Symfony 4.1 and support for it will be removed in 5.0. Implement the %s to check if the user has been changed,', __METHOD__, EquatableInterface::class), E_USER_DEPRECATED);
  336.             if ($this->user->isAccountNonExpired() !== $user->isAccountNonExpired()) {
  337.                 return true;
  338.             }
  340.             if ($this->user->isAccountNonLocked() !== $user->isAccountNonLocked()) {
  341.                 return true;
  342.             }
  344.             if ($this->user->isCredentialsNonExpired() !== $user->isCredentialsNonExpired()) {
  345.                 return true;
  346.             }
  348.             if ($this->user->isEnabled() !== $user->isEnabled()) {
  349.                 return true;
  350.             }
  351.         } elseif ($this->user instanceof AdvancedUserInterface xor $user instanceof AdvancedUserInterface) {
  352.             @trigger_error(sprintf('Checking for the AdvancedUserInterface in "%s()" is deprecated since Symfony 4.1 and support for it will be removed in 5.0. Implement the %s to check if the user has been changed,', __METHOD__, EquatableInterface::class), E_USER_DEPRECATED);
  354.             return true;
  355.         }
  357.         return false;
  358.     }
  359. }