vendor/symfony/security-bundle/DependencyInjection/SecurityExtension.php line 592

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\Bundle\SecurityBundle\DependencyInjection;
  14. use Symfony\Bridge\Twig\Extension\LogoutUrlExtension;
  15. use Symfony\Bundle\SecurityBundle\DependencyInjection\Security\Factory\AuthenticatorFactoryInterface;
  16. use Symfony\Bundle\SecurityBundle\DependencyInjection\Security\Factory\FirewallListenerFactoryInterface;
  17. use Symfony\Bundle\SecurityBundle\DependencyInjection\Security\UserProvider\UserProviderFactoryInterface;
  18. use Symfony\Component\Config\Definition\ConfigurationInterface;
  19. use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
  20. use Symfony\Component\Config\FileLocator;
  21. use Symfony\Component\Console\Application;
  22. use Symfony\Component\DependencyInjection\Alias;
  23. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  24. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  25. use Symfony\Component\DependencyInjection\ChildDefinition;
  26. use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
  27. use Symfony\Component\DependencyInjection\ContainerBuilder;
  28. use Symfony\Component\DependencyInjection\Definition;
  29. use Symfony\Component\DependencyInjection\Extension\PrependExtensionInterface;
  30. use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
  31. use Symfony\Component\DependencyInjection\Reference;
  32. use Symfony\Component\EventDispatcher\EventDispatcher;
  33. use Symfony\Component\ExpressionLanguage\Expression;
  34. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
  35. use Symfony\Component\HttpFoundation\RequestMatcher;
  36. use Symfony\Component\HttpKernel\DependencyInjection\Extension;
  37. use Symfony\Component\HttpKernel\KernelEvents;
  38. use Symfony\Component\PasswordHasher\Hasher\NativePasswordHasher;
  39. use Symfony\Component\PasswordHasher\Hasher\Pbkdf2PasswordHasher;
  40. use Symfony\Component\PasswordHasher\Hasher\PlaintextPasswordHasher;
  41. use Symfony\Component\PasswordHasher\Hasher\SodiumPasswordHasher;
  42. use Symfony\Component\Security\Core\Authorization\Strategy\AffirmativeStrategy;
  43. use Symfony\Component\Security\Core\Authorization\Strategy\ConsensusStrategy;
  44. use Symfony\Component\Security\Core\Authorization\Strategy\PriorityStrategy;
  45. use Symfony\Component\Security\Core\Authorization\Strategy\UnanimousStrategy;
  46. use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
  47. use Symfony\Component\Security\Core\User\ChainUserProvider;
  48. use Symfony\Component\Security\Core\User\UserCheckerInterface;
  49. use Symfony\Component\Security\Core\User\UserProviderInterface;
  50. use Symfony\Component\Security\Http\Authenticator\Debug\TraceableAuthenticatorManagerListener;
  51. use Symfony\Component\Security\Http\Event\CheckPassportEvent;
  53. /**
  54.  * SecurityExtension.
  55.  *
  56.  * @author Fabien Potencier <fabien@symfony.com>
  57.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  58.  */
  59. class SecurityExtension extends Extension implements PrependExtensionInterface
  60. {
  61.     private array $requestMatchers = [];
  62.     private array $expressions = [];
  63.     private array $contextListeners = [];
  64.     /** @var list<array{int, AuthenticatorFactoryInterface}> */
  65.     private array $factories = [];
  66.     /** @var AuthenticatorFactoryInterface[] */
  67.     private array $sortedFactories = [];
  68.     private array $userProviderFactories = [];
  70.     public function prepend(ContainerBuilder $container)
  71.     {
  72.         foreach ($this->getSortedFactories() as $factory) {
  73.             if ($factory instanceof PrependExtensionInterface) {
  74.                 $factory->prepend($container);
  75.             }
  76.         }
  77.     }
  79.     public function load(array $configs, ContainerBuilder $container)
  80.     {
  81.         if (!array_filter($configs)) {
  82.             return;
  83.         }
  85.         $mainConfig = $this->getConfiguration($configs, $container);
  87.         $config = $this->processConfiguration($mainConfig, $configs);
  89.         // load services
  90.         $loader = new PhpFileLoader($container, new FileLocator(\dirname(__DIR__).'/Resources/config'));
  92.         $loader->load('security.php');
  93.         $loader->load('password_hasher.php');
  94.         $loader->load('security_listeners.php');
  96.         if (!$config['enable_authenticator_manager']) {
  97.             throw new InvalidConfigurationException('"security.enable_authenticator_manager" must be set to "true".');
  98.         }
  100.         $loader->load('security_authenticator.php');
  102.         if ($container::willBeAvailable('symfony/twig-bridge', LogoutUrlExtension::class, ['symfony/security-bundle'])) {
  103.             $loader->load('templating_twig.php');
  104.         }
  106.         $loader->load('collectors.php');
  108.         if ($container->hasParameter('kernel.debug') && $container->getParameter('kernel.debug')) {
  109.             $loader->load('security_debug.php');
  110.         }
  112.         if (!$container::willBeAvailable('symfony/expression-language', ExpressionLanguage::class, ['symfony/security-bundle'])) {
  113.             $container->removeDefinition('security.expression_language');
  114.             $container->removeDefinition('security.access.expression_voter');
  115.         }
  117.         // set some global scalars
  118.         $container->setParameter('security.access.denied_url', $config['access_denied_url']);
  119.         $container->setParameter('security.authentication.manager.erase_credentials', $config['erase_credentials']);
  120.         $container->setParameter('security.authentication.session_strategy.strategy', $config['session_fixation_strategy']);
  122.         if (isset($config['access_decision_manager']['service'])) {
  123.             $container->setAlias('security.access.decision_manager', $config['access_decision_manager']['service']);
  124.         } elseif (isset($config['access_decision_manager']['strategy_service'])) {
  125.             $container
  126.                 ->getDefinition('security.access.decision_manager')
  127.                 ->addArgument(new Reference($config['access_decision_manager']['strategy_service']));
  128.         } else {
  129.             $container
  130.                 ->getDefinition('security.access.decision_manager')
  131.                 ->addArgument($this->createStrategyDefinition(
  132.                     $config['access_decision_manager']['strategy'] ?? MainConfiguration::STRATEGY_AFFIRMATIVE,
  133.                     $config['access_decision_manager']['allow_if_all_abstain'],
  134.                     $config['access_decision_manager']['allow_if_equal_granted_denied']
  135.                 ));
  136.         }
  138.         $container->setParameter('security.authentication.hide_user_not_found', $config['hide_user_not_found']);
  140.         if (class_exists(Application::class)) {
  141.             $loader->load('debug_console.php');
  142.         }
  144.         $this->createFirewalls($config, $container);
  145.         $this->createAuthorization($config, $container);
  146.         $this->createRoleHierarchy($config, $container);
  148.         if ($config['password_hashers']) {
  149.             $this->createHashers($config['password_hashers'], $container);
  150.         }
  152.         if (class_exists(Application::class)) {
  153.             $loader->load('console.php');
  155.             $container->getDefinition('security.command.user_password_hash')->replaceArgument(1, array_keys($config['password_hashers']));
  156.         }
  158.         $container->registerForAutoconfiguration(VoterInterface::class)
  159.             ->addTag('security.voter');
  161.         // required for compatibility with Symfony 5.4
  162.         $container->getDefinition('security.access_listener')->setArgument(3, false);
  163.         $container->getDefinition('security.authorization_checker')->setArgument(2, false);
  164.         $container->getDefinition('security.authorization_checker')->setArgument(3, false);
  165.     }
  167.     /**
  168.      * @throws \InvalidArgumentException if the $strategy is invalid
  169.      */
  170.     private function createStrategyDefinition(string $strategy, bool $allowIfAllAbstainDecisions, bool $allowIfEqualGrantedDeniedDecisions): Definition
  171.     {
  172.         switch ($strategy) {
  173.             case MainConfiguration::STRATEGY_AFFIRMATIVE:
  174.                 return new Definition(AffirmativeStrategy::class, [$allowIfAllAbstainDecisions]);
  175.             case MainConfiguration::STRATEGY_CONSENSUS:
  176.                 return new Definition(ConsensusStrategy::class, [$allowIfAllAbstainDecisions, $allowIfEqualGrantedDeniedDecisions]);
  177.             case MainConfiguration::STRATEGY_UNANIMOUS:
  178.                 return new Definition(UnanimousStrategy::class, [$allowIfAllAbstainDecisions]);
  179.             case MainConfiguration::STRATEGY_PRIORITY:
  180.                 return new Definition(PriorityStrategy::class, [$allowIfAllAbstainDecisions]);
  181.         }
  183.         throw new \InvalidArgumentException(sprintf('The strategy "%s" is not supported.', $strategy));
  184.     }
  186.     private function createRoleHierarchy(array $config, ContainerBuilder $container)
  187.     {
  188.         if (!isset($config['role_hierarchy']) || 0 === \count($config['role_hierarchy'])) {
  189.             $container->removeDefinition('security.access.role_hierarchy_voter');
  191.             return;
  192.         }
  194.         $container->setParameter('security.role_hierarchy.roles', $config['role_hierarchy']);
  195.         $container->removeDefinition('security.access.simple_role_voter');
  196.     }
  198.     private function createAuthorization(array $config, ContainerBuilder $container)
  199.     {
  200.         foreach ($config['access_control'] as $access) {
  201.             if (isset($access['request_matcher'])) {
  202.                 if ($access['path'] || $access['host'] || $access['port'] || $access['ips'] || $access['methods']) {
  203.                     throw new InvalidConfigurationException('The "request_matcher" option should not be specified alongside other options. Consider integrating your constraints inside your RequestMatcher directly.');
  204.                 }
  205.                 $matcher = new Reference($access['request_matcher']);
  206.             } else {
  207.                 $matcher = $this->createRequestMatcher(
  208.                     $container,
  209.                     $access['path'],
  210.                     $access['host'],
  211.                     $access['port'],
  212.                     $access['methods'],
  213.                     $access['ips']
  214.                 );
  215.             }
  217.             $attributes = $access['roles'];
  218.             if ($access['allow_if']) {
  219.                 $attributes[] = $this->createExpression($container, $access['allow_if']);
  220.             }
  222.             $emptyAccess = 0 === \count(array_filter($access));
  224.             if ($emptyAccess) {
  225.                 throw new InvalidConfigurationException('One or more access control items are empty. Did you accidentally add lines only containing a "-" under "security.access_control"?');
  226.             }
  228.             $container->getDefinition('security.access_map')
  229.                       ->addMethodCall('add', [$matcher, $attributes, $access['requires_channel']]);
  230.         }
  232.         // allow cache warm-up for expressions
  233.         if (\count($this->expressions)) {
  234.             $container->getDefinition('security.cache_warmer.expression')
  235.                 ->replaceArgument(0, new IteratorArgument(array_values($this->expressions)));
  236.         } else {
  237.             $container->removeDefinition('security.cache_warmer.expression');
  238.         }
  239.     }
  241.     private function createFirewalls(array $config, ContainerBuilder $container)
  242.     {
  243.         if (!isset($config['firewalls'])) {
  244.             return;
  245.         }
  247.         $firewalls = $config['firewalls'];
  248.         $providerIds = $this->createUserProviders($config, $container);
  250.         $container->setParameter('security.firewalls', array_keys($firewalls));
  252.         // make the ContextListener aware of the configured user providers
  253.         $contextListenerDefinition = $container->getDefinition('security.context_listener');
  254.         $arguments = $contextListenerDefinition->getArguments();
  255.         $userProviders = [];
  256.         foreach ($providerIds as $userProviderId) {
  257.             $userProviders[] = new Reference($userProviderId);
  258.         }
  259.         $arguments[1] = $userProviderIteratorsArgument = new IteratorArgument($userProviders);
  260.         $contextListenerDefinition->setArguments($arguments);
  261.         $nbUserProviders = \count($userProviders);
  263.         if ($nbUserProviders > 1) {
  264.             $container->setDefinition('security.user_providers', new Definition(ChainUserProvider::class, [$userProviderIteratorsArgument]))
  265.                 ->setPublic(false);
  266.         } elseif (0 === $nbUserProviders) {
  267.             $container->removeDefinition('security.listener.user_provider');
  268.         } else {
  269.             $container->setAlias('security.user_providers', new Alias(current($providerIds)))->setPublic(false);
  270.         }
  272.         if (1 === \count($providerIds)) {
  273.             $container->setAlias(UserProviderInterface::class, current($providerIds));
  274.         }
  276.         $customUserChecker = false;
  278.         // load firewall map
  279.         $mapDef = $container->getDefinition('security.firewall.map');
  280.         $map = $authenticationProviders = $contextRefs = [];
  281.         foreach ($firewalls as $name => $firewall) {
  282.             if (isset($firewall['user_checker']) && 'security.user_checker' !== $firewall['user_checker']) {
  283.                 $customUserChecker = true;
  284.             }
  286.             $configId = 'security.firewall.map.config.'.$name;
  288.             [$matcher, $listeners, $exceptionListener, $logoutListener] = $this->createFirewall($container, $name, $firewall, $authenticationProviders, $providerIds, $configId);
  290.             $contextId = 'security.firewall.map.context.'.$name;
  291.             $isLazy = !$firewall['stateless'] && (!empty($firewall['anonymous']['lazy']) || $firewall['lazy']);
  292.             $context = new ChildDefinition($isLazy ? 'security.firewall.lazy_context' : 'security.firewall.context');
  293.             $context = $container->setDefinition($contextId, $context);
  294.             $context
  295.                 ->replaceArgument(0, new IteratorArgument($listeners))
  296.                 ->replaceArgument(1, $exceptionListener)
  297.                 ->replaceArgument(2, $logoutListener)
  298.                 ->replaceArgument(3, new Reference($configId))
  299.             ;
  301.             $contextRefs[$contextId] = new Reference($contextId);
  302.             $map[$contextId] = $matcher;
  303.         }
  305.         $container->setAlias('security.firewall.context_locator', (string) ServiceLocatorTagPass::register($container, $contextRefs));
  307.         $mapDef->replaceArgument(0, new Reference('security.firewall.context_locator'));
  308.         $mapDef->replaceArgument(1, new IteratorArgument($map));
  310.         // register an autowire alias for the UserCheckerInterface if no custom user checker service is configured
  311.         if (!$customUserChecker) {
  312.             $container->setAlias(UserCheckerInterface::class, new Alias('security.user_checker', false));
  313.         }
  314.     }
  316.     private function createFirewall(ContainerBuilder $container, string $id, array $firewall, array &$authenticationProviders, array $providerIds, string $configId)
  317.     {
  318.         $config = $container->setDefinition($configId, new ChildDefinition('security.firewall.config'));
  319.         $config->replaceArgument(0, $id);
  320.         $config->replaceArgument(1, $firewall['user_checker']);
  322.         // Matcher
  323.         $matcher = null;
  324.         if (isset($firewall['request_matcher'])) {
  325.             $matcher = new Reference($firewall['request_matcher']);
  326.         } elseif (isset($firewall['pattern']) || isset($firewall['host'])) {
  327.             $pattern = $firewall['pattern'] ?? null;
  328.             $host = $firewall['host'] ?? null;
  329.             $methods = $firewall['methods'] ?? [];
  330.             $matcher = $this->createRequestMatcher($container, $pattern, $host, null, $methods);
  331.         }
  333.         $config->replaceArgument(2, $matcher ? (string) $matcher : null);
  334.         $config->replaceArgument(3, $firewall['security']);
  336.         // Security disabled?
  337.         if (false === $firewall['security']) {
  338.             return [$matcher, [], null, null];
  339.         }
  341.         $config->replaceArgument(4, $firewall['stateless']);
  343.         $firewallEventDispatcherId = 'security.event_dispatcher.'.$id;
  345.         // Provider id (must be configured explicitly per firewall/authenticator if more than one provider is set)
  346.         $defaultProvider = null;
  347.         if (isset($firewall['provider'])) {
  348.             if (!isset($providerIds[$normalizedName = str_replace('-', '_', $firewall['provider'])])) {
  349.                 throw new InvalidConfigurationException(sprintf('Invalid firewall "%s": user provider "%s" not found.', $id, $firewall['provider']));
  350.             }
  351.             $defaultProvider = $providerIds[$normalizedName];
  353.             $container->setDefinition('security.listener.'.$id.'.user_provider', new ChildDefinition('security.listener.user_provider.abstract'))
  354.                 ->addTag('kernel.event_listener', ['dispatcher' => $firewallEventDispatcherId, 'event' => CheckPassportEvent::class, 'priority' => 2048, 'method' => 'checkPassport'])
  355.                 ->replaceArgument(0, new Reference($defaultProvider));
  356.         } elseif (1 === \count($providerIds)) {
  357.             $defaultProvider = reset($providerIds);
  358.         }
  360.         $config->replaceArgument(5, $defaultProvider);
  362.         // Register Firewall-specific event dispatcher
  363.         $container->register($firewallEventDispatcherId, EventDispatcher::class)
  364.             ->addTag('event_dispatcher.dispatcher', ['name' => $firewallEventDispatcherId]);
  366.         // Register listeners
  367.         $listeners = [];
  368.         $listenerKeys = [];
  370.         // Channel listener
  371.         $listeners[] = new Reference('security.channel_listener');
  373.         $contextKey = null;
  374.         $contextListenerId = null;
  375.         // Context serializer listener
  376.         if (false === $firewall['stateless']) {
  377.             $contextKey = $firewall['context'] ?? $id;
  378.             $listeners[] = new Reference($contextListenerId = $this->createContextListener($container, $contextKey, $firewallEventDispatcherId));
  379.             $sessionStrategyId = 'security.authentication.session_strategy';
  381.             $container
  382.                 ->setDefinition('security.listener.session.'.$id, new ChildDefinition('security.listener.session'))
  383.                 ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  384.         } else {
  385.             $sessionStrategyId = 'security.authentication.session_strategy_noop';
  386.         }
  387.         $container->setAlias(new Alias('security.authentication.session_strategy.'.$id, false), $sessionStrategyId);
  389.         $config->replaceArgument(6, $contextKey);
  391.         // Logout listener
  392.         $logoutListenerId = null;
  393.         if (isset($firewall['logout'])) {
  394.             $logoutListenerId = 'security.logout_listener.'.$id;
  395.             $logoutListener = $container->setDefinition($logoutListenerId, new ChildDefinition('security.logout_listener'));
  396.             $logoutListener->replaceArgument(2, new Reference($firewallEventDispatcherId));
  397.             $logoutListener->replaceArgument(3, [
  398.                 'csrf_parameter' => $firewall['logout']['csrf_parameter'],
  399.                 'csrf_token_id' => $firewall['logout']['csrf_token_id'],
  400.                 'logout_path' => $firewall['logout']['path'],
  401.             ]);
  403.             $logoutSuccessListenerId = 'security.logout.listener.default.'.$id;
  404.             $container->setDefinition($logoutSuccessListenerId, new ChildDefinition('security.logout.listener.default'))
  405.                 ->replaceArgument(1, $firewall['logout']['target'])
  406.                 ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  408.             // add CSRF provider
  409.             if (isset($firewall['logout']['csrf_token_generator'])) {
  410.                 $logoutListener->addArgument(new Reference($firewall['logout']['csrf_token_generator']));
  411.             }
  413.             // add session logout listener
  414.             if (true === $firewall['logout']['invalidate_session'] && false === $firewall['stateless']) {
  415.                 $container->setDefinition('security.logout.listener.session.'.$id, new ChildDefinition('security.logout.listener.session'))
  416.                     ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  417.             }
  419.             // add cookie logout listener
  420.             if (\count($firewall['logout']['delete_cookies']) > 0) {
  421.                 $container->setDefinition('security.logout.listener.cookie_clearing.'.$id, new ChildDefinition('security.logout.listener.cookie_clearing'))
  422.                     ->addArgument($firewall['logout']['delete_cookies'])
  423.                     ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  424.             }
  426.             // register with LogoutUrlGenerator
  427.             $container
  428.                 ->getDefinition('security.logout_url_generator')
  429.                 ->addMethodCall('registerListener', [
  430.                     $id,
  431.                     $firewall['logout']['path'],
  432.                     $firewall['logout']['csrf_token_id'],
  433.                     $firewall['logout']['csrf_parameter'],
  434.                     isset($firewall['logout']['csrf_token_generator']) ? new Reference($firewall['logout']['csrf_token_generator']) : null,
  435.                     false === $firewall['stateless'] && isset($firewall['context']) ? $firewall['context'] : null,
  436.                 ])
  437.             ;
  438.         }
  440.         // Determine default entry point
  441.         $configuredEntryPoint = $firewall['entry_point'] ?? null;
  443.         // Authentication listeners
  444.         $firewallAuthenticationProviders = [];
  445.         [$authListeners, $defaultEntryPoint] = $this->createAuthenticationListeners($container, $id, $firewall, $firewallAuthenticationProviders, $defaultProvider, $providerIds, $configuredEntryPoint, $contextListenerId);
  447.         // $configuredEntryPoint is resolved into a service ID and stored in $defaultEntryPoint
  448.         $configuredEntryPoint = $defaultEntryPoint;
  450.         // authenticator manager
  451.         $authenticators = array_map(function ($id) {
  452.             return new Reference($id);
  453.         }, $firewallAuthenticationProviders);
  454.         $container
  455.             ->setDefinition($managerId = 'security.authenticator.manager.'.$id, new ChildDefinition('security.authenticator.manager'))
  456.             ->replaceArgument(0, $authenticators)
  457.             ->replaceArgument(2, new Reference($firewallEventDispatcherId))
  458.             ->replaceArgument(3, $id)
  459.             ->replaceArgument(7, $firewall['required_badges'] ?? [])
  460.             ->addTag('monolog.logger', ['channel' => 'security'])
  461.         ;
  463.         $managerLocator = $container->getDefinition('security.authenticator.managers_locator');
  464.         $managerLocator->replaceArgument(0, array_merge($managerLocator->getArgument(0), [$id => new ServiceClosureArgument(new Reference($managerId))]));
  466.         // authenticator manager listener
  467.         $container
  468.             ->setDefinition('security.firewall.authenticator.'.$id, new ChildDefinition('security.firewall.authenticator'))
  469.             ->replaceArgument(0, new Reference($managerId))
  470.         ;
  472.         if ($container->hasDefinition('debug.security.firewall')) {
  473.             $container
  474.                 ->register('debug.security.firewall.authenticator.'.$id, TraceableAuthenticatorManagerListener::class)
  475.                 ->setDecoratedService('security.firewall.authenticator.'.$id)
  476.                 ->setArguments([new Reference('debug.security.firewall.authenticator.'.$id.'.inner')])
  477.             ;
  478.         }
  480.         // user checker listener
  481.         $container
  482.             ->setDefinition('security.listener.user_checker.'.$id, new ChildDefinition('security.listener.user_checker'))
  483.             ->replaceArgument(0, new Reference('security.user_checker.'.$id))
  484.             ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  486.         $listeners[] = new Reference('security.firewall.authenticator.'.$id);
  488.         // Add authenticators to the debug:firewall command
  489.         if ($container->hasDefinition('security.command.debug_firewall')) {
  490.             $debugCommand = $container->getDefinition('security.command.debug_firewall');
  491.             $debugCommand->replaceArgument(3, array_merge($debugCommand->getArgument(3), [$id => $authenticators]));
  492.         }
  494.         $config->replaceArgument(7, $configuredEntryPoint ?: $defaultEntryPoint);
  496.         $listeners = array_merge($listeners, $authListeners);
  498.         // Switch user listener
  499.         if (isset($firewall['switch_user'])) {
  500.             $listenerKeys[] = 'switch_user';
  501.             $listeners[] = new Reference($this->createSwitchUserListener($container, $id, $firewall['switch_user'], $defaultProvider, $firewall['stateless']));
  502.         }
  504.         // Access listener
  505.         $listeners[] = new Reference('security.access_listener');
  507.         // Exception listener
  508.         $exceptionListener = new Reference($this->createExceptionListener($container, $firewall, $id, $configuredEntryPoint ?: $defaultEntryPoint, $firewall['stateless']));
  510.         $config->replaceArgument(8, $firewall['access_denied_handler'] ?? null);
  511.         $config->replaceArgument(9, $firewall['access_denied_url'] ?? null);
  513.         $container->setAlias('security.user_checker.'.$id, new Alias($firewall['user_checker'], false));
  515.         foreach ($this->getSortedFactories() as $factory) {
  516.             $key = str_replace('-', '_', $factory->getKey());
  517.             if ('custom_authenticators' !== $key && \array_key_exists($key, $firewall)) {
  518.                 $listenerKeys[] = $key;
  519.             }
  520.         }
  522.         if ($firewall['custom_authenticators'] ?? false) {
  523.             foreach ($firewall['custom_authenticators'] as $customAuthenticatorId) {
  524.                 $listenerKeys[] = $customAuthenticatorId;
  525.             }
  526.         }
  528.         $config->replaceArgument(10, $listenerKeys);
  529.         $config->replaceArgument(11, $firewall['switch_user'] ?? null);
  531.         return [$matcher, $listeners, $exceptionListener, null !== $logoutListenerId ? new Reference($logoutListenerId) : null];
  532.     }
  534.     private function createContextListener(ContainerBuilder $container, string $contextKey, ?string $firewallEventDispatcherId)
  535.     {
  536.         if (isset($this->contextListeners[$contextKey])) {
  537.             return $this->contextListeners[$contextKey];
  538.         }
  540.         $listenerId = 'security.context_listener.'.\count($this->contextListeners);
  541.         $listener = $container->setDefinition($listenerId, new ChildDefinition('security.context_listener'));
  542.         $listener->replaceArgument(2, $contextKey);
  543.         if (null !== $firewallEventDispatcherId) {
  544.             $listener->replaceArgument(4, new Reference($firewallEventDispatcherId));
  545.             $listener->addTag('kernel.event_listener', ['event' => KernelEvents::RESPONSE, 'method' => 'onKernelResponse']);
  546.         }
  548.         return $this->contextListeners[$contextKey] = $listenerId;
  549.     }
  551.     private function createAuthenticationListeners(ContainerBuilder $container, string $id, array $firewall, array &$authenticationProviders, ?string $defaultProvider, array $providerIds, ?string $defaultEntryPoint, string $contextListenerId = null)
  552.     {
  553.         $listeners = [];
  554.         $entryPoints = [];
  556.         foreach ($this->getSortedFactories() as $factory) {
  557.             $key = str_replace('-', '_', $factory->getKey());
  559.             if (isset($firewall[$key])) {
  560.                 $userProvider = $this->getUserProvider($container, $id, $firewall, $key, $defaultProvider, $providerIds, $contextListenerId);
  562.                 if (!$factory instanceof AuthenticatorFactoryInterface) {
  563.                     throw new InvalidConfigurationException(sprintf('Authenticator factory "%s" ("%s") must implement "%s".', get_debug_type($factory), $key, AuthenticatorFactoryInterface::class));
  564.                 }
  566.                 $authenticators = $factory->createAuthenticator($container, $id, $firewall[$key], $userProvider);
  567.                 if (\is_array($authenticators)) {
  568.                     foreach ($authenticators as $authenticator) {
  569.                         $authenticationProviders[] = $authenticator;
  570.                         $entryPoints[] = $authenticator;
  571.                     }
  572.                 } else {
  573.                     $authenticationProviders[] = $authenticators;
  574.                     $entryPoints[$key] = $authenticators;
  575.                 }
  577.                 if ($factory instanceof FirewallListenerFactoryInterface) {
  578.                     $firewallListenerIds = $factory->createListeners($container, $id, $firewall[$key]);
  579.                     foreach ($firewallListenerIds as $firewallListenerId) {
  580.                         $listeners[] = new Reference($firewallListenerId);
  581.                     }
  582.                 }
  583.             }
  584.         }
  586.         // the actual entry point is configured by the RegisterEntryPointPass
  587.         $container->setParameter('security.'.$id.'._indexed_authenticators', $entryPoints);
  589.         return [$listeners, $defaultEntryPoint];
  590.     }
  592.     private function getUserProvider(ContainerBuilder $container, string $id, array $firewall, string $factoryKey, ?string $defaultProvider, array $providerIds, ?string $contextListenerId): string
  593.     {
  594.         if (isset($firewall[$factoryKey]['provider'])) {
  595.             if (!isset($providerIds[$normalizedName = str_replace('-', '_', $firewall[$factoryKey]['provider'])])) {
  596.                 throw new InvalidConfigurationException(sprintf('Invalid firewall "%s": user provider "%s" not found.', $id, $firewall[$factoryKey]['provider']));
  597.             }
  599.             return $providerIds[$normalizedName];
  600.         }
  602.         if ('remember_me' === $factoryKey && $contextListenerId) {
  603.             $container->getDefinition($contextListenerId)->addTag('security.remember_me_aware', ['id' => $id, 'provider' => 'none']);
  604.         }
  606.         if ($defaultProvider) {
  607.             return $defaultProvider;
  608.         }
  610.         if (!$providerIds) {
  611.             $userProvider = sprintf('security.user.provider.missing.%s', $factoryKey);
  612.             $container->setDefinition(
  613.                 $userProvider,
  614.                 (new ChildDefinition('security.user.provider.missing'))->replaceArgument(0, $id)
  615.             );
  617.             return $userProvider;
  618.         }
  620.         if ('remember_me' === $factoryKey || 'anonymous' === $factoryKey || 'custom_authenticators' === $factoryKey) {
  621.             if ('custom_authenticators' === $factoryKey) {
  622.                 trigger_deprecation('symfony/security-bundle', '5.4', 'Not configuring explicitly the provider for the "%s" firewall is deprecated because it\'s ambiguous as there is more than one registered provider. Set the "provider" key to one of the configured providers, even if your custom authenticators don\'t use it.', $id);
  623.             }
  625.             return 'security.user_providers';
  626.         }
  628.         throw new InvalidConfigurationException(sprintf('Not configuring explicitly the provider for the "%s" authenticator on "%s" firewall is ambiguous as there is more than one registered provider.', $factoryKey, $id));
  629.     }
  631.     private function createHashers(array $hashers, ContainerBuilder $container)
  632.     {
  633.         $hasherMap = [];
  634.         foreach ($hashers as $class => $hasher) {
  635.             $hasherMap[$class] = $this->createHasher($hasher);
  636.         }
  638.         $container
  639.             ->getDefinition('security.password_hasher_factory')
  640.             ->setArguments([$hasherMap])
  641.         ;
  642.     }
  644.     private function createHasher(array $config)
  645.     {
  646.         // a custom hasher service
  647.         if (isset($config['id'])) {
  648.             return new Reference($config['id']);
  649.         }
  651.         if ($config['migrate_from'] ?? false) {
  652.             return $config;
  653.         }
  655.         // plaintext hasher
  656.         if ('plaintext' === $config['algorithm']) {
  657.             $arguments = [$config['ignore_case']];
  659.             return [
  660.                 'class' => PlaintextPasswordHasher::class,
  661.                 'arguments' => $arguments,
  662.             ];
  663.         }
  665.         // pbkdf2 hasher
  666.         if ('pbkdf2' === $config['algorithm']) {
  667.             return [
  668.                 'class' => Pbkdf2PasswordHasher::class,
  669.                 'arguments' => [
  670.                     $config['hash_algorithm'],
  671.                     $config['encode_as_base64'],
  672.                     $config['iterations'],
  673.                     $config['key_length'],
  674.                 ],
  675.             ];
  676.         }
  678.         // bcrypt hasher
  679.         if ('bcrypt' === $config['algorithm']) {
  680.             $config['algorithm'] = 'native';
  681.             $config['native_algorithm'] = \PASSWORD_BCRYPT;
  683.             return $this->createHasher($config);
  684.         }
  686.         // Argon2i hasher
  687.         if ('argon2i' === $config['algorithm']) {
  688.             if (SodiumPasswordHasher::isSupported() && !\defined('SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13')) {
  689.                 $config['algorithm'] = 'sodium';
  690.             } elseif (\defined('PASSWORD_ARGON2I')) {
  691.                 $config['algorithm'] = 'native';
  692.                 $config['native_algorithm'] = \PASSWORD_ARGON2I;
  693.             } else {
  694.                 throw new InvalidConfigurationException(sprintf('Algorithm "argon2i" is not available. Either use "%s" or upgrade to PHP 7.2+ instead.', \defined('SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13') ? 'argon2id", "auto' : 'auto'));
  695.             }
  697.             return $this->createHasher($config);
  698.         }
  700.         if ('argon2id' === $config['algorithm']) {
  701.             if (($hasSodium = SodiumPasswordHasher::isSupported()) && \defined('SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13')) {
  702.                 $config['algorithm'] = 'sodium';
  703.             } elseif (\defined('PASSWORD_ARGON2ID')) {
  704.                 $config['algorithm'] = 'native';
  705.                 $config['native_algorithm'] = \PASSWORD_ARGON2ID;
  706.             } else {
  707.                 throw new InvalidConfigurationException(sprintf('Algorithm "argon2id" is not available. Either use "%s", upgrade to PHP 7.3+ or use libsodium 1.0.15+ instead.', \defined('PASSWORD_ARGON2I') || $hasSodium ? 'argon2i", "auto' : 'auto'));
  708.             }
  710.             return $this->createHasher($config);
  711.         }
  713.         if ('native' === $config['algorithm']) {
  714.             return [
  715.                 'class' => NativePasswordHasher::class,
  716.                 'arguments' => [
  717.                     $config['time_cost'],
  718.                     (($config['memory_cost'] ?? 0) << 10) ?: null,
  719.                     $config['cost'],
  720.                 ] + (isset($config['native_algorithm']) ? [3 => $config['native_algorithm']] : []),
  721.             ];
  722.         }
  724.         if ('sodium' === $config['algorithm']) {
  725.             if (!SodiumPasswordHasher::isSupported()) {
  726.                 throw new InvalidConfigurationException('Libsodium is not available. Install the sodium extension or use "auto" instead.');
  727.             }
  729.             return [
  730.                 'class' => SodiumPasswordHasher::class,
  731.                 'arguments' => [
  732.                     $config['time_cost'],
  733.                     (($config['memory_cost'] ?? 0) << 10) ?: null,
  734.                 ],
  735.             ];
  736.         }
  738.         // run-time configured hasher
  739.         return $config;
  740.     }
  742.     // Parses user providers and returns an array of their ids
  743.     private function createUserProviders(array $config, ContainerBuilder $container): array
  744.     {
  745.         $providerIds = [];
  746.         foreach ($config['providers'] as $name => $provider) {
  747.             $id = $this->createUserDaoProvider($name, $provider, $container);
  748.             $providerIds[str_replace('-', '_', $name)] = $id;
  749.         }
  751.         return $providerIds;
  752.     }
  754.     // Parses a <provider> tag and returns the id for the related user provider service
  755.     private function createUserDaoProvider(string $name, array $provider, ContainerBuilder $container): string
  756.     {
  757.         $name = $this->getUserProviderId($name);
  759.         // Doctrine Entity and In-memory DAO provider are managed by factories
  760.         foreach ($this->userProviderFactories as $factory) {
  761.             $key = str_replace('-', '_', $factory->getKey());
  763.             if (!empty($provider[$key])) {
  764.                 $factory->create($container, $name, $provider[$key]);
  766.                 return $name;
  767.             }
  768.         }
  770.         // Existing DAO service provider
  771.         if (isset($provider['id'])) {
  772.             $container->setAlias($name, new Alias($provider['id'], false));
  774.             return $provider['id'];
  775.         }
  777.         // Chain provider
  778.         if (isset($provider['chain'])) {
  779.             $providers = [];
  780.             foreach ($provider['chain']['providers'] as $providerName) {
  781.                 $providers[] = new Reference($this->getUserProviderId($providerName));
  782.             }
  784.             $container
  785.                 ->setDefinition($name, new ChildDefinition('security.user.provider.chain'))
  786.                 ->addArgument(new IteratorArgument($providers));
  788.             return $name;
  789.         }
  791.         throw new InvalidConfigurationException(sprintf('Unable to create definition for "%s" user provider.', $name));
  792.     }
  794.     private function getUserProviderId(string $name): string
  795.     {
  796.         return 'security.user.provider.concrete.'.strtolower($name);
  797.     }
  799.     private function createExceptionListener(ContainerBuilder $container, array $config, string $id, ?string $defaultEntryPoint, bool $stateless): string
  800.     {
  801.         $exceptionListenerId = 'security.exception_listener.'.$id;
  802.         $listener = $container->setDefinition($exceptionListenerId, new ChildDefinition('security.exception_listener'));
  803.         $listener->replaceArgument(3, $id);
  804.         $listener->replaceArgument(4, null === $defaultEntryPoint ? null : new Reference($defaultEntryPoint));
  805.         $listener->replaceArgument(8, $stateless);
  807.         // access denied handler setup
  808.         if (isset($config['access_denied_handler'])) {
  809.             $listener->replaceArgument(6, new Reference($config['access_denied_handler']));
  810.         } elseif (isset($config['access_denied_url'])) {
  811.             $listener->replaceArgument(5, $config['access_denied_url']);
  812.         }
  814.         return $exceptionListenerId;
  815.     }
  817.     private function createSwitchUserListener(ContainerBuilder $container, string $id, array $config, ?string $defaultProvider, bool $stateless): string
  818.     {
  819.         $userProvider = isset($config['provider']) ? $this->getUserProviderId($config['provider']) : $defaultProvider;
  821.         if (!$userProvider) {
  822.             throw new InvalidConfigurationException(sprintf('Not configuring explicitly the provider for the "switch_user" listener on "%s" firewall is ambiguous as there is more than one registered provider.', $id));
  823.         }
  825.         $switchUserListenerId = 'security.authentication.switchuser_listener.'.$id;
  826.         $listener = $container->setDefinition($switchUserListenerId, new ChildDefinition('security.authentication.switchuser_listener'));
  827.         $listener->replaceArgument(1, new Reference($userProvider));
  828.         $listener->replaceArgument(2, new Reference('security.user_checker.'.$id));
  829.         $listener->replaceArgument(3, $id);
  830.         $listener->replaceArgument(6, $config['parameter']);
  831.         $listener->replaceArgument(7, $config['role']);
  832.         $listener->replaceArgument(9, $stateless);
  834.         return $switchUserListenerId;
  835.     }
  837.     private function createExpression(ContainerBuilder $container, string $expression): Reference
  838.     {
  839.         if (isset($this->expressions[$id = '.security.expression.'.ContainerBuilder::hash($expression)])) {
  840.             return $this->expressions[$id];
  841.         }
  843.         if (!$container::willBeAvailable('symfony/expression-language', ExpressionLanguage::class, ['symfony/security-bundle'])) {
  844.             throw new \RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed. Try running "composer require symfony/expression-language".');
  845.         }
  847.         $container
  848.             ->register($id, Expression::class)
  849.             ->setPublic(false)
  850.             ->addArgument($expression)
  851.         ;
  853.         return $this->expressions[$id] = new Reference($id);
  854.     }
  856.     private function createRequestMatcher(ContainerBuilder $container, string $path = null, string $host = null, int $port = null, array $methods = [], array $ips = null, array $attributes = []): Reference
  857.     {
  858.         if ($methods) {
  859.             $methods = array_map('strtoupper', $methods);
  860.         }
  862.         if (null !== $ips) {
  863.             foreach ($ips as $ip) {
  864.                 $container->resolveEnvPlaceholders($ip, null, $usedEnvs);
  866.                 if (!$usedEnvs && !$this->isValidIps($ip)) {
  867.                     throw new \LogicException(sprintf('The given value "%s" in the "security.access_control" config option is not a valid IP address.', $ip));
  868.                 }
  870.                 $usedEnvs = null;
  871.             }
  872.         }
  874.         $id = '.security.request_matcher.'.ContainerBuilder::hash([$path, $host, $port, $methods, $ips, $attributes]);
  876.         if (isset($this->requestMatchers[$id])) {
  877.             return $this->requestMatchers[$id];
  878.         }
  880.         // only add arguments that are necessary
  881.         $arguments = [$path, $host, $methods, $ips, $attributes, null, $port];
  882.         while (\count($arguments) > 0 && !end($arguments)) {
  883.             array_pop($arguments);
  884.         }
  886.         $container
  887.             ->register($id, RequestMatcher::class)
  888.             ->setPublic(false)
  889.             ->setArguments($arguments)
  890.         ;
  892.         return $this->requestMatchers[$id] = new Reference($id);
  893.     }
  895.     public function addAuthenticatorFactory(AuthenticatorFactoryInterface $factory)
  896.     {
  897.         $this->factories[] = [$factory->getPriority(), $factory];
  898.         $this->sortedFactories = [];
  899.     }
  901.     public function addUserProviderFactory(UserProviderFactoryInterface $factory)
  902.     {
  903.         $this->userProviderFactories[] = $factory;
  904.     }
  906.     /**
  907.      * {@inheritdoc}
  908.      */
  909.     public function getXsdValidationBasePath(): string|false
  910.     {
  911.         return __DIR__.'/../Resources/config/schema';
  912.     }
  914.     public function getNamespace(): string
  915.     {
  916.         return 'http://symfony.com/schema/dic/security';
  917.     }
  919.     public function getConfiguration(array $config, ContainerBuilder $container): ?ConfigurationInterface
  920.     {
  921.         // first assemble the factories
  922.         return new MainConfiguration($this->getSortedFactories(), $this->userProviderFactories);
  923.     }
  925.     private function isValidIps(string|array $ips): bool
  926.     {
  927.         $ipsList = array_reduce((array) $ips, static function (array $ips, string $ip) {
  928.             return array_merge($ips, preg_split('/\s*,\s*/', $ip));
  929.         }, []);
  931.         if (!$ipsList) {
  932.             return false;
  933.         }
  935.         foreach ($ipsList as $cidr) {
  936.             if (!$this->isValidIp($cidr)) {
  937.                 return false;
  938.             }
  939.         }
  941.         return true;
  942.     }
  944.     private function isValidIp(string $cidr): bool
  945.     {
  946.         $cidrParts = explode('/', $cidr);
  948.         if (1 === \count($cidrParts)) {
  949.             return false !== filter_var($cidrParts[0], \FILTER_VALIDATE_IP);
  950.         }
  952.         $ip = $cidrParts[0];
  953.         $netmask = $cidrParts[1];
  955.         if (!ctype_digit($netmask)) {
  956.             return false;
  957.         }
  959.         if (filter_var($ip, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV4)) {
  960.             return $netmask <= 32;
  961.         }
  963.         if (filter_var($ip, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV6)) {
  964.             return $netmask <= 128;
  965.         }
  967.         return false;
  968.     }
  970.     /**
  971.      * @return array<int, AuthenticatorFactoryInterface>
  972.      */
  973.     private function getSortedFactories(): array
  974.     {
  975.         if (!$this->sortedFactories) {
  976.             $factories = [];
  977.             foreach ($this->factories as $i => $factory) {
  978.                 $factories[] = array_merge($factory, [$i]);
  979.             }
  981.             usort($factories, function ($a, $b) {
  982.                 return $b[0] <=> $a[0] ?: $a[2] <=> $b[2];
  983.             });
  985.             $this->sortedFactories = array_column($factories, 1);
  986.         }
  988.         return $this->sortedFactories;
  989.     }
  990. }