vendor/symfony/security-core/Authorization/AccessDecisionManager.php line 84

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\Authorization;
  14. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  15. use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
  16. use Symfony\Component\Security\Core\Exception\InvalidArgumentException;
  18. /**
  19.  * AccessDecisionManager is the base class for all access decision managers
  20.  * that use decision voters.
  21.  *
  22.  * @author Fabien Potencier <fabien@symfony.com>
  23.  */
  24. class AccessDecisionManager implements AccessDecisionManagerInterface
  25. {
  26.     public const STRATEGY_AFFIRMATIVE = 'affirmative';
  27.     public const STRATEGY_CONSENSUS = 'consensus';
  28.     public const STRATEGY_UNANIMOUS = 'unanimous';
  29.     public const STRATEGY_PRIORITY = 'priority';
  31.     private $voters;
  32.     private $strategy;
  33.     private $allowIfAllAbstainDecisions;
  34.     private $allowIfEqualGrantedDeniedDecisions;
  36.     /**
  37.      * @param iterable|VoterInterface[] $voters                             An array or an iterator of VoterInterface instances
  38.      * @param string                    $strategy                           The vote strategy
  39.      * @param bool                      $allowIfAllAbstainDecisions         Whether to grant access if all voters abstained or not
  40.      * @param bool                      $allowIfEqualGrantedDeniedDecisions Whether to grant access if result are equals
  41.      *
  42.      * @throws \InvalidArgumentException
  43.      */
  44.     public function __construct(iterable $voters = [], string $strategy = self::STRATEGY_AFFIRMATIVE, bool $allowIfAllAbstainDecisions = false, bool $allowIfEqualGrantedDeniedDecisions = true)
  45.     {
  46.         $strategyMethod = 'decide'.ucfirst($strategy);
  47.         if ('' === $strategy || !\is_callable([$this, $strategyMethod])) {
  48.             throw new \InvalidArgumentException(sprintf('The strategy "%s" is not supported.', $strategy));
  49.         }
  51.         $this->voters = $voters;
  52.         $this->strategy = $strategyMethod;
  53.         $this->allowIfAllAbstainDecisions = $allowIfAllAbstainDecisions;
  54.         $this->allowIfEqualGrantedDeniedDecisions = $allowIfEqualGrantedDeniedDecisions;
  55.     }
  57.     /**
  58.      * @param bool $allowMultipleAttributes Whether to allow passing multiple values to the $attributes array
  59.      *
  60.      * {@inheritdoc}
  61.      */
  62.     public function decide(TokenInterface $token, array $attributes, $object = null/*, bool $allowMultipleAttributes = false*/)
  63.     {
  64.         $allowMultipleAttributes = 3 < \func_num_args() && func_get_arg(3);
  66.         // Special case for AccessListener, do not remove the right side of the condition before 6.0
  67.         if (\count($attributes) > 1 && !$allowMultipleAttributes) {
  68.             throw new InvalidArgumentException(sprintf('Passing more than one Security attribute to "%s()" is not supported.', __METHOD__));
  69.         }
  71.         return $this->{$this->strategy}($token, $attributes, $object);
  72.     }
  74.     /**
  75.      * Grants access if any voter returns an affirmative response.
  76.      *
  77.      * If all voters abstained from voting, the decision will be based on the
  78.      * allowIfAllAbstainDecisions property value (defaults to false).
  79.      */
  80.     private function decideAffirmative(TokenInterface $token, array $attributes, $object = null): bool
  81.     {
  82.         $deny = 0;
  83.         foreach ($this->voters as $voter) {
  84.             $result = $voter->vote($token, $object, $attributes);
  86.             if (VoterInterface::ACCESS_GRANTED === $result) {
  87.                 return true;
  88.             }
  90.             if (VoterInterface::ACCESS_DENIED === $result) {
  91.                 ++$deny;
  92.             } elseif (VoterInterface::ACCESS_ABSTAIN !== $result) {
  93.                 trigger_deprecation('symfony/security-core', '5.3', 'Returning "%s" in "%s::vote()" is deprecated, return one of "%s" constants: "ACCESS_GRANTED", "ACCESS_DENIED" or "ACCESS_ABSTAIN".', var_export($result, true), get_debug_type($voter), VoterInterface::class);
  94.             }
  95.         }
  97.         if ($deny > 0) {
  98.             return false;
  99.         }
  101.         return $this->allowIfAllAbstainDecisions;
  102.     }
  104.     /**
  105.      * Grants access if there is consensus of granted against denied responses.
  106.      *
  107.      * Consensus means majority-rule (ignoring abstains) rather than unanimous
  108.      * agreement (ignoring abstains). If you require unanimity, see
  109.      * UnanimousBased.
  110.      *
  111.      * If there were an equal number of grant and deny votes, the decision will
  112.      * be based on the allowIfEqualGrantedDeniedDecisions property value
  113.      * (defaults to true).
  114.      *
  115.      * If all voters abstained from voting, the decision will be based on the
  116.      * allowIfAllAbstainDecisions property value (defaults to false).
  117.      */
  118.     private function decideConsensus(TokenInterface $token, array $attributes, $object = null): bool
  119.     {
  120.         $grant = 0;
  121.         $deny = 0;
  122.         foreach ($this->voters as $voter) {
  123.             $result = $voter->vote($token, $object, $attributes);
  125.             if (VoterInterface::ACCESS_GRANTED === $result) {
  126.                 ++$grant;
  127.             } elseif (VoterInterface::ACCESS_DENIED === $result) {
  128.                 ++$deny;
  129.             } elseif (VoterInterface::ACCESS_ABSTAIN !== $result) {
  130.                 trigger_deprecation('symfony/security-core', '5.3', 'Returning "%s" in "%s::vote()" is deprecated, return one of "%s" constants: "ACCESS_GRANTED", "ACCESS_DENIED" or "ACCESS_ABSTAIN".', var_export($result, true), get_debug_type($voter), VoterInterface::class);
  131.             }
  132.         }
  134.         if ($grant > $deny) {
  135.             return true;
  136.         }
  138.         if ($deny > $grant) {
  139.             return false;
  140.         }
  142.         if ($grant > 0) {
  143.             return $this->allowIfEqualGrantedDeniedDecisions;
  144.         }
  146.         return $this->allowIfAllAbstainDecisions;
  147.     }
  149.     /**
  150.      * Grants access if only grant (or abstain) votes were received.
  151.      *
  152.      * If all voters abstained from voting, the decision will be based on the
  153.      * allowIfAllAbstainDecisions property value (defaults to false).
  154.      */
  155.     private function decideUnanimous(TokenInterface $token, array $attributes, $object = null): bool
  156.     {
  157.         $grant = 0;
  158.         foreach ($this->voters as $voter) {
  159.             foreach ($attributes as $attribute) {
  160.                 $result = $voter->vote($token, $object, [$attribute]);
  162.                 if (VoterInterface::ACCESS_DENIED === $result) {
  163.                     return false;
  164.                 }
  166.                 if (VoterInterface::ACCESS_GRANTED === $result) {
  167.                     ++$grant;
  168.                 } elseif (VoterInterface::ACCESS_ABSTAIN !== $result) {
  169.                     trigger_deprecation('symfony/security-core', '5.3', 'Returning "%s" in "%s::vote()" is deprecated, return one of "%s" constants: "ACCESS_GRANTED", "ACCESS_DENIED" or "ACCESS_ABSTAIN".', var_export($result, true), get_debug_type($voter), VoterInterface::class);
  170.                 }
  171.             }
  172.         }
  174.         // no deny votes
  175.         if ($grant > 0) {
  176.             return true;
  177.         }
  179.         return $this->allowIfAllAbstainDecisions;
  180.     }
  182.     /**
  183.      * Grant or deny access depending on the first voter that does not abstain.
  184.      * The priority of voters can be used to overrule a decision.
  185.      *
  186.      * If all voters abstained from voting, the decision will be based on the
  187.      * allowIfAllAbstainDecisions property value (defaults to false).
  188.      */
  189.     private function decidePriority(TokenInterface $token, array $attributes, $object = null)
  190.     {
  191.         foreach ($this->voters as $voter) {
  192.             $result = $voter->vote($token, $object, $attributes);
  194.             if (VoterInterface::ACCESS_GRANTED === $result) {
  195.                 return true;
  196.             }
  198.             if (VoterInterface::ACCESS_DENIED === $result) {
  199.                 return false;
  200.             }
  202.             if (VoterInterface::ACCESS_ABSTAIN !== $result) {
  203.                 trigger_deprecation('symfony/security-core', '5.3', 'Returning "%s" in "%s::vote()" is deprecated, return one of "%s" constants: "ACCESS_GRANTED", "ACCESS_DENIED" or "ACCESS_ABSTAIN".', var_export($result, true), get_debug_type($voter), VoterInterface::class);
  204.             }
  205.         }
  207.         return $this->allowIfAllAbstainDecisions;
  208.     }
  209. }