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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  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\ExpressionLanguage;
  34. use Symfony\Component\HttpKernel\DependencyInjection\Extension;
  35. use Symfony\Component\HttpKernel\KernelEvents;
  36. use Symfony\Component\PasswordHasher\Hasher\NativePasswordHasher;
  37. use Symfony\Component\PasswordHasher\Hasher\Pbkdf2PasswordHasher;
  38. use Symfony\Component\PasswordHasher\Hasher\PlaintextPasswordHasher;
  39. use Symfony\Component\PasswordHasher\Hasher\SodiumPasswordHasher;
  40. use Symfony\Component\Security\Core\Authorization\Strategy\AffirmativeStrategy;
  41. use Symfony\Component\Security\Core\Authorization\Strategy\ConsensusStrategy;
  42. use Symfony\Component\Security\Core\Authorization\Strategy\PriorityStrategy;
  43. use Symfony\Component\Security\Core\Authorization\Strategy\UnanimousStrategy;
  44. use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
  45. use Symfony\Component\Security\Core\User\ChainUserProvider;
  46. use Symfony\Component\Security\Core\User\UserProviderInterface;
  47. use Symfony\Component\Security\Http\Authenticator\Debug\TraceableAuthenticatorManagerListener;
  48. use Symfony\Component\Security\Http\Event\CheckPassportEvent;
  50. /**
  51.  * SecurityExtension.
  52.  *
  53.  * @author Fabien Potencier <[email protected]>
  54.  * @author Johannes M. Schmitt <[email protected]>
  55.  */
  56. class SecurityExtension extends Extension implements PrependExtensionInterface
  57. {
  58.     private array $requestMatchers = [];
  59.     private array $expressions = [];
  60.     private array $contextListeners = [];
  61.     /** @var list<array{int, AuthenticatorFactoryInterface}> */
  62.     private array $factories = [];
  63.     /** @var AuthenticatorFactoryInterface[] */
  64.     private array $sortedFactories = [];
  65.     private array $userProviderFactories = [];
  67.     public function prepend(ContainerBuilder $container)
  68.     {
  69.         foreach ($this->getSortedFactories() as $factory) {
  70.             if ($factory instanceof PrependExtensionInterface) {
  71.                 $factory->prepend($container);
  72.             }
  73.         }
  74.     }
  76.     public function load(array $configs, ContainerBuilder $container)
  77.     {
  78.         if (!array_filter($configs)) {
  79.             return;
  80.         }
  82.         $mainConfig = $this->getConfiguration($configs, $container);
  84.         $config = $this->processConfiguration($mainConfig, $configs);
  86.         // load services
  87.         $loader = new PhpFileLoader($container, new FileLocator(\dirname(__DIR__).'/Resources/config'));
  89.         $loader->load('security.php');
  90.         $loader->load('password_hasher.php');
  91.         $loader->load('security_listeners.php');
  93.         if (!$config['enable_authenticator_manager']) {
  94.             throw new InvalidConfigurationException('"security.enable_authenticator_manager" must be set to "true".');
  95.         }
  97.         $loader->load('security_authenticator.php');
  99.         if ($container::willBeAvailable('symfony/twig-bridge', LogoutUrlExtension::class, ['symfony/security-bundle'])) {
  100.             $loader->load('templating_twig.php');
  101.         }
  103.         $loader->load('collectors.php');
  105.         if ($container->hasParameter('kernel.debug') && $container->getParameter('kernel.debug')) {
  106.             $loader->load('security_debug.php');
  107.         }
  109.         if (!$container::willBeAvailable('symfony/expression-language', ExpressionLanguage::class, ['symfony/security-bundle'])) {
  110.             $container->removeDefinition('security.expression_language');
  111.             $container->removeDefinition('security.access.expression_voter');
  112.         }
  114.         // set some global scalars
  115.         $container->setParameter('security.access.denied_url', $config['access_denied_url']);
  116.         $container->setParameter('security.authentication.manager.erase_credentials', $config['erase_credentials']);
  117.         $container->setParameter('security.authentication.session_strategy.strategy', $config['session_fixation_strategy']);
  119.         if (isset($config['access_decision_manager']['service'])) {
  120.             $container->setAlias('security.access.decision_manager', $config['access_decision_manager']['service']);
  121.         } elseif (isset($config['access_decision_manager']['strategy_service'])) {
  122.             $container
  123.                 ->getDefinition('security.access.decision_manager')
  124.                 ->addArgument(new Reference($config['access_decision_manager']['strategy_service']));
  125.         } else {
  126.             $container
  127.                 ->getDefinition('security.access.decision_manager')
  128.                 ->addArgument($this->createStrategyDefinition(
  129.                     $config['access_decision_manager']['strategy'] ?? MainConfiguration::STRATEGY_AFFIRMATIVE,
  130.                     $config['access_decision_manager']['allow_if_all_abstain'],
  131.                     $config['access_decision_manager']['allow_if_equal_granted_denied']
  132.                 ));
  133.         }
  135.         $container->setParameter('security.authentication.hide_user_not_found', $config['hide_user_not_found']);
  137.         if (class_exists(Application::class)) {
  138.             $loader->load('debug_console.php');
  139.         }
  141.         $this->createFirewalls($config, $container);
  142.         $this->createAuthorization($config, $container);
  143.         $this->createRoleHierarchy($config, $container);
  145.         if ($config['password_hashers']) {
  146.             $this->createHashers($config['password_hashers'], $container);
  147.         }
  149.         if (class_exists(Application::class)) {
  150.             $loader->load('console.php');
  152.             $container->getDefinition('security.command.user_password_hash')->replaceArgument(1, array_keys($config['password_hashers']));
  153.         }
  155.         $container->registerForAutoconfiguration(VoterInterface::class)
  156.             ->addTag('security.voter');
  158.         // required for compatibility with Symfony 5.4
  159.         $container->getDefinition('security.access_listener')->setArgument(3, false);
  160.         $container->getDefinition('security.authorization_checker')->setArgument(2, false);
  161.         $container->getDefinition('security.authorization_checker')->setArgument(3, false);
  162.     }
  164.     /**
  165.      * @throws \InvalidArgumentException if the $strategy is invalid
  166.      */
  167.     private function createStrategyDefinition(string $strategy, bool $allowIfAllAbstainDecisions, bool $allowIfEqualGrantedDeniedDecisions): Definition
  168.     {
  169.         switch ($strategy) {
  170.             case MainConfiguration::STRATEGY_AFFIRMATIVE:
  171.                 return new Definition(AffirmativeStrategy::class, [$allowIfAllAbstainDecisions]);
  172.             case MainConfiguration::STRATEGY_CONSENSUS:
  173.                 return new Definition(ConsensusStrategy::class, [$allowIfAllAbstainDecisions, $allowIfEqualGrantedDeniedDecisions]);
  174.             case MainConfiguration::STRATEGY_UNANIMOUS:
  175.                 return new Definition(UnanimousStrategy::class, [$allowIfAllAbstainDecisions]);
  176.             case MainConfiguration::STRATEGY_PRIORITY:
  177.                 return new Definition(PriorityStrategy::class, [$allowIfAllAbstainDecisions]);
  178.         }
  180.         throw new \InvalidArgumentException(sprintf('The strategy "%s" is not supported.', $strategy));
  181.     }
  183.     private function createRoleHierarchy(array $config, ContainerBuilder $container)
  184.     {
  185.         if (!isset($config['role_hierarchy']) || 0 === \count($config['role_hierarchy'])) {
  186.             $container->removeDefinition('security.access.role_hierarchy_voter');
  188.             return;
  189.         }
  191.         $container->setParameter('security.role_hierarchy.roles', $config['role_hierarchy']);
  192.         $container->removeDefinition('security.access.simple_role_voter');
  193.     }
  195.     private function createAuthorization(array $config, ContainerBuilder $container)
  196.     {
  197.         foreach ($config['access_control'] as $access) {
  198.             $matcher = $this->createRequestMatcher(
  199.                 $container,
  200.                 $access['path'],
  201.                 $access['host'],
  202.                 $access['port'],
  203.                 $access['methods'],
  204.                 $access['ips']
  205.             );
  207.             $attributes = $access['roles'];
  208.             if ($access['allow_if']) {
  209.                 $attributes[] = $this->createExpression($container, $access['allow_if']);
  210.             }
  212.             $emptyAccess = 0 === \count(array_filter($access));
  214.             if ($emptyAccess) {
  215.                 throw new InvalidConfigurationException('One or more access control items are empty. Did you accidentally add lines only containing a "-" under "security.access_control"?');
  216.             }
  218.             $container->getDefinition('security.access_map')
  219.                       ->addMethodCall('add', [$matcher, $attributes, $access['requires_channel']]);
  220.         }
  222.         // allow cache warm-up for expressions
  223.         if (\count($this->expressions)) {
  224.             $container->getDefinition('security.cache_warmer.expression')
  225.                 ->replaceArgument(0, new IteratorArgument(array_values($this->expressions)));
  226.         } else {
  227.             $container->removeDefinition('security.cache_warmer.expression');
  228.         }
  229.     }
  231.     private function createFirewalls(array $config, ContainerBuilder $container)
  232.     {
  233.         if (!isset($config['firewalls'])) {
  234.             return;
  235.         }
  237.         $firewalls = $config['firewalls'];
  238.         $providerIds = $this->createUserProviders($config, $container);
  240.         $container->setParameter('security.firewalls', array_keys($firewalls));
  242.         // make the ContextListener aware of the configured user providers
  243.         $contextListenerDefinition = $container->getDefinition('security.context_listener');
  244.         $arguments = $contextListenerDefinition->getArguments();
  245.         $userProviders = [];
  246.         foreach ($providerIds as $userProviderId) {
  247.             $userProviders[] = new Reference($userProviderId);
  248.         }
  249.         $arguments[1] = $userProviderIteratorsArgument = new IteratorArgument($userProviders);
  250.         $contextListenerDefinition->setArguments($arguments);
  251.         $nbUserProviders = \count($userProviders);
  253.         if ($nbUserProviders > 1) {
  254.             $container->setDefinition('security.user_providers', new Definition(ChainUserProvider::class, [$userProviderIteratorsArgument]))
  255.                 ->setPublic(false);
  256.         } elseif (0 === $nbUserProviders) {
  257.             $container->removeDefinition('security.listener.user_provider');
  258.         } else {
  259.             $container->setAlias('security.user_providers', new Alias(current($providerIds)))->setPublic(false);
  260.         }
  262.         if (1 === \count($providerIds)) {
  263.             $container->setAlias(UserProviderInterface::class, current($providerIds));
  264.         }
  266.         $customUserChecker = false;
  268.         // load firewall map
  269.         $mapDef = $container->getDefinition('security.firewall.map');
  270.         $map = $authenticationProviders = $contextRefs = [];
  271.         foreach ($firewalls as $name => $firewall) {
  272.             if (isset($firewall['user_checker']) && 'security.user_checker' !== $firewall['user_checker']) {
  273.                 $customUserChecker = true;
  274.             }
  276.             $configId = 'security.firewall.map.config.'.$name;
  278.             [$matcher, $listeners, $exceptionListener, $logoutListener] = $this->createFirewall($container, $name, $firewall, $authenticationProviders, $providerIds, $configId);
  280.             $contextId = 'security.firewall.map.context.'.$name;
  281.             $isLazy = !$firewall['stateless'] && (!empty($firewall['anonymous']['lazy']) || $firewall['lazy']);
  282.             $context = new ChildDefinition($isLazy ? 'security.firewall.lazy_context' : 'security.firewall.context');
  283.             $context = $container->setDefinition($contextId, $context);
  284.             $context
  285.                 ->replaceArgument(0, new IteratorArgument($listeners))
  286.                 ->replaceArgument(1, $exceptionListener)
  287.                 ->replaceArgument(2, $logoutListener)
  288.                 ->replaceArgument(3, new Reference($configId))
  289.             ;
  291.             $contextRefs[$contextId] = new Reference($contextId);
  292.             $map[$contextId] = $matcher;
  293.         }
  295.         $container->setAlias('security.firewall.context_locator', (string) ServiceLocatorTagPass::register($container, $contextRefs));
  297.         $mapDef->replaceArgument(0, new Reference('security.firewall.context_locator'));
  298.         $mapDef->replaceArgument(1, new IteratorArgument($map));
  300.         // register an autowire alias for the UserCheckerInterface if no custom user checker service is configured
  301.         if (!$customUserChecker) {
  302.             $container->setAlias('Symfony\Component\Security\Core\User\UserCheckerInterface', new Alias('security.user_checker', false));
  303.         }
  304.     }
  306.     private function createFirewall(ContainerBuilder $container, string $id, array $firewall, array &$authenticationProviders, array $providerIds, string $configId)
  307.     {
  308.         $config = $container->setDefinition($configId, new ChildDefinition('security.firewall.config'));
  309.         $config->replaceArgument(0, $id);
  310.         $config->replaceArgument(1, $firewall['user_checker']);
  312.         // Matcher
  313.         $matcher = null;
  314.         if (isset($firewall['request_matcher'])) {
  315.             $matcher = new Reference($firewall['request_matcher']);
  316.         } elseif (isset($firewall['pattern']) || isset($firewall['host'])) {
  317.             $pattern = $firewall['pattern'] ?? null;
  318.             $host = $firewall['host'] ?? null;
  319.             $methods = $firewall['methods'] ?? [];
  320.             $matcher = $this->createRequestMatcher($container, $pattern, $host, null, $methods);
  321.         }
  323.         $config->replaceArgument(2, $matcher ? (string) $matcher : null);
  324.         $config->replaceArgument(3, $firewall['security']);
  326.         // Security disabled?
  327.         if (false === $firewall['security']) {
  328.             return [$matcher, [], null, null];
  329.         }
  331.         $config->replaceArgument(4, $firewall['stateless']);
  333.         $firewallEventDispatcherId = 'security.event_dispatcher.'.$id;
  335.         // Provider id (must be configured explicitly per firewall/authenticator if more than one provider is set)
  336.         $defaultProvider = null;
  337.         if (isset($firewall['provider'])) {
  338.             if (!isset($providerIds[$normalizedName = str_replace('-', '_', $firewall['provider'])])) {
  339.                 throw new InvalidConfigurationException(sprintf('Invalid firewall "%s": user provider "%s" not found.', $id, $firewall['provider']));
  340.             }
  341.             $defaultProvider = $providerIds[$normalizedName];
  343.             $container->setDefinition('security.listener.'.$id.'.user_provider', new ChildDefinition('security.listener.user_provider.abstract'))
  344.                 ->addTag('kernel.event_listener', ['dispatcher' => $firewallEventDispatcherId, 'event' => CheckPassportEvent::class, 'priority' => 2048, 'method' => 'checkPassport'])
  345.                 ->replaceArgument(0, new Reference($defaultProvider));
  346.         } elseif (1 === \count($providerIds)) {
  347.             $defaultProvider = reset($providerIds);
  348.         }
  350.         $config->replaceArgument(5, $defaultProvider);
  352.         // Register Firewall-specific event dispatcher
  353.         $container->register($firewallEventDispatcherId, EventDispatcher::class)
  354.             ->addTag('event_dispatcher.dispatcher', ['name' => $firewallEventDispatcherId]);
  356.         // Register listeners
  357.         $listeners = [];
  358.         $listenerKeys = [];
  360.         // Channel listener
  361.         $listeners[] = new Reference('security.channel_listener');
  363.         $contextKey = null;
  364.         $contextListenerId = null;
  365.         // Context serializer listener
  366.         if (false === $firewall['stateless']) {
  367.             $contextKey = $firewall['context'] ?? $id;
  368.             $listeners[] = new Reference($contextListenerId = $this->createContextListener($container, $contextKey, $firewallEventDispatcherId));
  369.             $sessionStrategyId = 'security.authentication.session_strategy';
  371.             $container
  372.                 ->setDefinition('security.listener.session.'.$id, new ChildDefinition('security.listener.session'))
  373.                 ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  374.         } else {
  375.             $sessionStrategyId = 'security.authentication.session_strategy_noop';
  376.         }
  377.         $container->setAlias(new Alias('security.authentication.session_strategy.'.$id, false), $sessionStrategyId);
  379.         $config->replaceArgument(6, $contextKey);
  381.         // Logout listener
  382.         $logoutListenerId = null;
  383.         if (isset($firewall['logout'])) {
  384.             $logoutListenerId = 'security.logout_listener.'.$id;
  385.             $logoutListener = $container->setDefinition($logoutListenerId, new ChildDefinition('security.logout_listener'));
  386.             $logoutListener->replaceArgument(2, new Reference($firewallEventDispatcherId));
  387.             $logoutListener->replaceArgument(3, [
  388.                 'csrf_parameter' => $firewall['logout']['csrf_parameter'],
  389.                 'csrf_token_id' => $firewall['logout']['csrf_token_id'],
  390.                 'logout_path' => $firewall['logout']['path'],
  391.             ]);
  393.             $logoutSuccessListenerId = 'security.logout.listener.default.'.$id;
  394.             $container->setDefinition($logoutSuccessListenerId, new ChildDefinition('security.logout.listener.default'))
  395.                 ->replaceArgument(1, $firewall['logout']['target'])
  396.                 ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  398.             // add CSRF provider
  399.             if (isset($firewall['logout']['csrf_token_generator'])) {
  400.                 $logoutListener->addArgument(new Reference($firewall['logout']['csrf_token_generator']));
  401.             }
  403.             // add session logout listener
  404.             if (true === $firewall['logout']['invalidate_session'] && false === $firewall['stateless']) {
  405.                 $container->setDefinition('security.logout.listener.session.'.$id, new ChildDefinition('security.logout.listener.session'))
  406.                     ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  407.             }
  409.             // add cookie logout listener
  410.             if (\count($firewall['logout']['delete_cookies']) > 0) {
  411.                 $container->setDefinition('security.logout.listener.cookie_clearing.'.$id, new ChildDefinition('security.logout.listener.cookie_clearing'))
  412.                     ->addArgument($firewall['logout']['delete_cookies'])
  413.                     ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  414.             }
  416.             // register with LogoutUrlGenerator
  417.             $container
  418.                 ->getDefinition('security.logout_url_generator')
  419.                 ->addMethodCall('registerListener', [
  420.                     $id,
  421.                     $firewall['logout']['path'],
  422.                     $firewall['logout']['csrf_token_id'],
  423.                     $firewall['logout']['csrf_parameter'],
  424.                     isset($firewall['logout']['csrf_token_generator']) ? new Reference($firewall['logout']['csrf_token_generator']) : null,
  425.                     false === $firewall['stateless'] && isset($firewall['context']) ? $firewall['context'] : null,
  426.                 ])
  427.             ;
  428.         }
  430.         // Determine default entry point
  431.         $configuredEntryPoint = $firewall['entry_point'] ?? null;
  433.         // Authentication listeners
  434.         $firewallAuthenticationProviders = [];
  435.         [$authListeners, $defaultEntryPoint] = $this->createAuthenticationListeners($container, $id, $firewall, $firewallAuthenticationProviders, $defaultProvider, $providerIds, $configuredEntryPoint, $contextListenerId);
  437.         // $configuredEntryPoint is resolved into a service ID and stored in $defaultEntryPoint
  438.         $configuredEntryPoint = $defaultEntryPoint;
  440.         // authenticator manager
  441.         $authenticators = array_map(function ($id) {
  442.             return new Reference($id);
  443.         }, $firewallAuthenticationProviders);
  444.         $container
  445.             ->setDefinition($managerId = 'security.authenticator.manager.'.$id, new ChildDefinition('security.authenticator.manager'))
  446.             ->replaceArgument(0, $authenticators)
  447.             ->replaceArgument(2, new Reference($firewallEventDispatcherId))
  448.             ->replaceArgument(3, $id)
  449.             ->replaceArgument(7, $firewall['required_badges'] ?? [])
  450.             ->addTag('monolog.logger', ['channel' => 'security'])
  451.         ;
  453.         $managerLocator = $container->getDefinition('security.authenticator.managers_locator');
  454.         $managerLocator->replaceArgument(0, array_merge($managerLocator->getArgument(0), [$id => new ServiceClosureArgument(new Reference($managerId))]));
  456.         // authenticator manager listener
  457.         $container
  458.             ->setDefinition('security.firewall.authenticator.'.$id, new ChildDefinition('security.firewall.authenticator'))
  459.             ->replaceArgument(0, new Reference($managerId))
  460.         ;
  462.         if ($container->hasDefinition('debug.security.firewall')) {
  463.             $container
  464.                 ->register('debug.security.firewall.authenticator.'.$id, TraceableAuthenticatorManagerListener::class)
  465.                 ->setDecoratedService('security.firewall.authenticator.'.$id)
  466.                 ->setArguments([new Reference('debug.security.firewall.authenticator.'.$id.'.inner')])
  467.             ;
  468.         }
  470.         // user checker listener
  471.         $container
  472.             ->setDefinition('security.listener.user_checker.'.$id, new ChildDefinition('security.listener.user_checker'))
  473.             ->replaceArgument(0, new Reference('security.user_checker.'.$id))
  474.             ->addTag('kernel.event_subscriber', ['dispatcher' => $firewallEventDispatcherId]);
  476.         $listeners[] = new Reference('security.firewall.authenticator.'.$id);
  478.         // Add authenticators to the debug:firewall command
  479.         if ($container->hasDefinition('security.command.debug_firewall')) {
  480.             $debugCommand = $container->getDefinition('security.command.debug_firewall');
  481.             $debugCommand->replaceArgument(3, array_merge($debugCommand->getArgument(3), [$id => $authenticators]));
  482.         }
  484.         $config->replaceArgument(7, $configuredEntryPoint ?: $defaultEntryPoint);
  486.         $listeners = array_merge($listeners, $authListeners);
  488.         // Switch user listener
  489.         if (isset($firewall['switch_user'])) {
  490.             $listenerKeys[] = 'switch_user';
  491.             $listeners[] = new Reference($this->createSwitchUserListener($container, $id, $firewall['switch_user'], $defaultProvider, $firewall['stateless']));
  492.         }
  494.         // Access listener
  495.         $listeners[] = new Reference('security.access_listener');
  497.         // Exception listener
  498.         $exceptionListener = new Reference($this->createExceptionListener($container, $firewall, $id, $configuredEntryPoint ?: $defaultEntryPoint, $firewall['stateless']));
  500.         $config->replaceArgument(8, $firewall['access_denied_handler'] ?? null);
  501.         $config->replaceArgument(9, $firewall['access_denied_url'] ?? null);
  503.         $container->setAlias('security.user_checker.'.$id, new Alias($firewall['user_checker'], false));
  505.         foreach ($this->getSortedFactories() as $factory) {
  506.             $key = str_replace('-', '_', $factory->getKey());
  507.             if ('custom_authenticators' !== $key && \array_key_exists($key, $firewall)) {
  508.                 $listenerKeys[] = $key;
  509.             }
  510.         }
  512.         if ($firewall['custom_authenticators'] ?? false) {
  513.             foreach ($firewall['custom_authenticators'] as $customAuthenticatorId) {
  514.                 $listenerKeys[] = $customAuthenticatorId;
  515.             }
  516.         }
  518.         $config->replaceArgument(10, $listenerKeys);
  519.         $config->replaceArgument(11, $firewall['switch_user'] ?? null);
  521.         return [$matcher, $listeners, $exceptionListener, null !== $logoutListenerId ? new Reference($logoutListenerId) : null];
  522.     }
  524.     private function createContextListener(ContainerBuilder $container, string $contextKey, ?string $firewallEventDispatcherId)
  525.     {
  526.         if (isset($this->contextListeners[$contextKey])) {
  527.             return $this->contextListeners[$contextKey];
  528.         }
  530.         $listenerId = 'security.context_listener.'.\count($this->contextListeners);
  531.         $listener = $container->setDefinition($listenerId, new ChildDefinition('security.context_listener'));
  532.         $listener->replaceArgument(2, $contextKey);
  533.         if (null !== $firewallEventDispatcherId) {
  534.             $listener->replaceArgument(4, new Reference($firewallEventDispatcherId));
  535.             $listener->addTag('kernel.event_listener', ['event' => KernelEvents::RESPONSE, 'method' => 'onKernelResponse']);
  536.         }
  538.         return $this->contextListeners[$contextKey] = $listenerId;
  539.     }
  541.     private function createAuthenticationListeners(ContainerBuilder $container, string $id, array $firewall, array &$authenticationProviders, ?string $defaultProvider, array $providerIds, ?string $defaultEntryPoint, string $contextListenerId = null)
  542.     {
  543.         $listeners = [];
  544.         $entryPoints = [];
  546.         foreach ($this->getSortedFactories() as $factory) {
  547.             $key = str_replace('-', '_', $factory->getKey());
  549.             if (isset($firewall[$key])) {
  550.                 $userProvider = $this->getUserProvider($container, $id, $firewall, $key, $defaultProvider, $providerIds, $contextListenerId);
  552.                 if (!$factory instanceof AuthenticatorFactoryInterface) {
  553.                     throw new InvalidConfigurationException(sprintf('Authenticator factory "%s" ("%s") must implement "%s".', get_debug_type($factory), $key, AuthenticatorFactoryInterface::class));
  554.                 }
  556.                 $authenticators = $factory->createAuthenticator($container, $id, $firewall[$key], $userProvider);
  557.                 if (\is_array($authenticators)) {
  558.                     foreach ($authenticators as $authenticator) {
  559.                         $authenticationProviders[] = $authenticator;
  560.                         $entryPoints[] = $authenticator;
  561.                     }
  562.                 } else {
  563.                     $authenticationProviders[] = $authenticators;
  564.                     $entryPoints[$key] = $authenticators;
  565.                 }
  567.                 if ($factory instanceof FirewallListenerFactoryInterface) {
  568.                     $firewallListenerIds = $factory->createListeners($container, $id, $firewall[$key]);
  569.                     foreach ($firewallListenerIds as $firewallListenerId) {
  570.                         $listeners[] = new Reference($firewallListenerId);
  571.                     }
  572.                 }
  573.             }
  574.         }
  576.         // the actual entry point is configured by the RegisterEntryPointPass
  577.         $container->setParameter('security.'.$id.'._indexed_authenticators', $entryPoints);
  579.         return [$listeners, $defaultEntryPoint];
  580.     }
  582.     private function getUserProvider(ContainerBuilder $container, string $id, array $firewall, string $factoryKey, ?string $defaultProvider, array $providerIds, ?string $contextListenerId): string
  583.     {
  584.         if (isset($firewall[$factoryKey]['provider'])) {
  585.             if (!isset($providerIds[$normalizedName = str_replace('-', '_', $firewall[$factoryKey]['provider'])])) {
  586.                 throw new InvalidConfigurationException(sprintf('Invalid firewall "%s": user provider "%s" not found.', $id, $firewall[$factoryKey]['provider']));
  587.             }
  589.             return $providerIds[$normalizedName];
  590.         }
  592.         if ('remember_me' === $factoryKey && $contextListenerId) {
  593.             $container->getDefinition($contextListenerId)->addTag('security.remember_me_aware', ['id' => $id, 'provider' => 'none']);
  594.         }
  596.         if ($defaultProvider) {
  597.             return $defaultProvider;
  598.         }
  600.         if (!$providerIds) {
  601.             $userProvider = sprintf('security.user.provider.missing.%s', $factoryKey);
  602.             $container->setDefinition(
  603.                 $userProvider,
  604.                 (new ChildDefinition('security.user.provider.missing'))->replaceArgument(0, $id)
  605.             );
  607.             return $userProvider;
  608.         }
  610.         if ('remember_me' === $factoryKey || 'anonymous' === $factoryKey || 'custom_authenticators' === $factoryKey) {
  611.             if ('custom_authenticators' === $factoryKey) {
  612.                 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);
  613.             }
  615.             return 'security.user_providers';
  616.         }
  618.         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));
  619.     }
  621.     private function createHashers(array $hashers, ContainerBuilder $container)
  622.     {
  623.         $hasherMap = [];
  624.         foreach ($hashers as $class => $hasher) {
  625.             $hasherMap[$class] = $this->createHasher($hasher);
  626.         }
  628.         $container
  629.             ->getDefinition('security.password_hasher_factory')
  630.             ->setArguments([$hasherMap])
  631.         ;
  632.     }
  634.     private function createHasher(array $config)
  635.     {
  636.         // a custom hasher service
  637.         if (isset($config['id'])) {
  638.             return new Reference($config['id']);
  639.         }
  641.         if ($config['migrate_from'] ?? false) {
  642.             return $config;
  643.         }
  645.         // plaintext hasher
  646.         if ('plaintext' === $config['algorithm']) {
  647.             $arguments = [$config['ignore_case']];
  649.             return [
  650.                 'class' => PlaintextPasswordHasher::class,
  651.                 'arguments' => $arguments,
  652.             ];
  653.         }
  655.         // pbkdf2 hasher
  656.         if ('pbkdf2' === $config['algorithm']) {
  657.             return [
  658.                 'class' => Pbkdf2PasswordHasher::class,
  659.                 'arguments' => [
  660.                     $config['hash_algorithm'],
  661.                     $config['encode_as_base64'],
  662.                     $config['iterations'],
  663.                     $config['key_length'],
  664.                 ],
  665.             ];
  666.         }
  668.         // bcrypt hasher
  669.         if ('bcrypt' === $config['algorithm']) {
  670.             $config['algorithm'] = 'native';
  671.             $config['native_algorithm'] = \PASSWORD_BCRYPT;
  673.             return $this->createHasher($config);
  674.         }
  676.         // Argon2i hasher
  677.         if ('argon2i' === $config['algorithm']) {
  678.             if (SodiumPasswordHasher::isSupported() && !\defined('SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13')) {
  679.                 $config['algorithm'] = 'sodium';
  680.             } elseif (\defined('PASSWORD_ARGON2I')) {
  681.                 $config['algorithm'] = 'native';
  682.                 $config['native_algorithm'] = \PASSWORD_ARGON2I;
  683.             } else {
  684.                 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'));
  685.             }
  687.             return $this->createHasher($config);
  688.         }
  690.         if ('argon2id' === $config['algorithm']) {
  691.             if (($hasSodium = SodiumPasswordHasher::isSupported()) && \defined('SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13')) {
  692.                 $config['algorithm'] = 'sodium';
  693.             } elseif (\defined('PASSWORD_ARGON2ID')) {
  694.                 $config['algorithm'] = 'native';
  695.                 $config['native_algorithm'] = \PASSWORD_ARGON2ID;
  696.             } else {
  697.                 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'));
  698.             }
  700.             return $this->createHasher($config);
  701.         }
  703.         if ('native' === $config['algorithm']) {
  704.             return [
  705.                 'class' => NativePasswordHasher::class,
  706.                 'arguments' => [
  707.                     $config['time_cost'],
  708.                     (($config['memory_cost'] ?? 0) << 10) ?: null,
  709.                     $config['cost'],
  710.                 ] + (isset($config['native_algorithm']) ? [3 => $config['native_algorithm']] : []),
  711.             ];
  712.         }
  714.         if ('sodium' === $config['algorithm']) {
  715.             if (!SodiumPasswordHasher::isSupported()) {
  716.                 throw new InvalidConfigurationException('Libsodium is not available. Install the sodium extension or use "auto" instead.');
  717.             }
  719.             return [
  720.                 'class' => SodiumPasswordHasher::class,
  721.                 'arguments' => [
  722.                     $config['time_cost'],
  723.                     (($config['memory_cost'] ?? 0) << 10) ?: null,
  724.                 ],
  725.             ];
  726.         }
  728.         // run-time configured hasher
  729.         return $config;
  730.     }
  732.     // Parses user providers and returns an array of their ids
  733.     private function createUserProviders(array $config, ContainerBuilder $container): array
  734.     {
  735.         $providerIds = [];
  736.         foreach ($config['providers'] as $name => $provider) {
  737.             $id = $this->createUserDaoProvider($name, $provider, $container);
  738.             $providerIds[str_replace('-', '_', $name)] = $id;
  739.         }
  741.         return $providerIds;
  742.     }
  744.     // Parses a <provider> tag and returns the id for the related user provider service
  745.     private function createUserDaoProvider(string $name, array $provider, ContainerBuilder $container): string
  746.     {
  747.         $name = $this->getUserProviderId($name);
  749.         // Doctrine Entity and In-memory DAO provider are managed by factories
  750.         foreach ($this->userProviderFactories as $factory) {
  751.             $key = str_replace('-', '_', $factory->getKey());
  753.             if (!empty($provider[$key])) {
  754.                 $factory->create($container, $name, $provider[$key]);
  756.                 return $name;
  757.             }
  758.         }
  760.         // Existing DAO service provider
  761.         if (isset($provider['id'])) {
  762.             $container->setAlias($name, new Alias($provider['id'], false));
  764.             return $provider['id'];
  765.         }
  767.         // Chain provider
  768.         if (isset($provider['chain'])) {
  769.             $providers = [];
  770.             foreach ($provider['chain']['providers'] as $providerName) {
  771.                 $providers[] = new Reference($this->getUserProviderId($providerName));
  772.             }
  774.             $container
  775.                 ->setDefinition($name, new ChildDefinition('security.user.provider.chain'))
  776.                 ->addArgument(new IteratorArgument($providers));
  778.             return $name;
  779.         }
  781.         throw new InvalidConfigurationException(sprintf('Unable to create definition for "%s" user provider.', $name));
  782.     }
  784.     private function getUserProviderId(string $name): string
  785.     {
  786.         return 'security.user.provider.concrete.'.strtolower($name);
  787.     }
  789.     private function createExceptionListener(ContainerBuilder $container, array $config, string $id, ?string $defaultEntryPoint, bool $stateless): string
  790.     {
  791.         $exceptionListenerId = 'security.exception_listener.'.$id;
  792.         $listener = $container->setDefinition($exceptionListenerId, new ChildDefinition('security.exception_listener'));
  793.         $listener->replaceArgument(3, $id);
  794.         $listener->replaceArgument(4, null === $defaultEntryPoint ? null : new Reference($defaultEntryPoint));
  795.         $listener->replaceArgument(8, $stateless);
  797.         // access denied handler setup
  798.         if (isset($config['access_denied_handler'])) {
  799.             $listener->replaceArgument(6, new Reference($config['access_denied_handler']));
  800.         } elseif (isset($config['access_denied_url'])) {
  801.             $listener->replaceArgument(5, $config['access_denied_url']);
  802.         }
  804.         return $exceptionListenerId;
  805.     }
  807.     private function createSwitchUserListener(ContainerBuilder $container, string $id, array $config, ?string $defaultProvider, bool $stateless): string
  808.     {
  809.         $userProvider = isset($config['provider']) ? $this->getUserProviderId($config['provider']) : $defaultProvider;
  811.         if (!$userProvider) {
  812.             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));
  813.         }
  815.         $switchUserListenerId = 'security.authentication.switchuser_listener.'.$id;
  816.         $listener = $container->setDefinition($switchUserListenerId, new ChildDefinition('security.authentication.switchuser_listener'));
  817.         $listener->replaceArgument(1, new Reference($userProvider));
  818.         $listener->replaceArgument(2, new Reference('security.user_checker.'.$id));
  819.         $listener->replaceArgument(3, $id);
  820.         $listener->replaceArgument(6, $config['parameter']);
  821.         $listener->replaceArgument(7, $config['role']);
  822.         $listener->replaceArgument(9, $stateless);
  824.         return $switchUserListenerId;
  825.     }
  827.     private function createExpression(ContainerBuilder $container, string $expression): Reference
  828.     {
  829.         if (isset($this->expressions[$id = '.security.expression.'.ContainerBuilder::hash($expression)])) {
  830.             return $this->expressions[$id];
  831.         }
  833.         if (!$container::willBeAvailable('symfony/expression-language', ExpressionLanguage::class, ['symfony/security-bundle'])) {
  834.             throw new \RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed. Try running "composer require symfony/expression-language".');
  835.         }
  837.         $container
  838.             ->register($id, 'Symfony\Component\ExpressionLanguage\Expression')
  839.             ->setPublic(false)
  840.             ->addArgument($expression)
  841.         ;
  843.         return $this->expressions[$id] = new Reference($id);
  844.     }
  846.     private function createRequestMatcher(ContainerBuilder $container, string $path = null, string $host = null, int $port = null, array $methods = [], array $ips = null, array $attributes = []): Reference
  847.     {
  848.         if ($methods) {
  849.             $methods = array_map('strtoupper', $methods);
  850.         }
  852.         if (null !== $ips) {
  853.             foreach ($ips as $ip) {
  854.                 $container->resolveEnvPlaceholders($ip, null, $usedEnvs);
  856.                 if (!$usedEnvs && !$this->isValidIps($ip)) {
  857.                     throw new \LogicException(sprintf('The given value "%s" in the "security.access_control" config option is not a valid IP address.', $ip));
  858.                 }
  860.                 $usedEnvs = null;
  861.             }
  862.         }
  864.         $id = '.security.request_matcher.'.ContainerBuilder::hash([$path, $host, $port, $methods, $ips, $attributes]);
  866.         if (isset($this->requestMatchers[$id])) {
  867.             return $this->requestMatchers[$id];
  868.         }
  870.         // only add arguments that are necessary
  871.         $arguments = [$path, $host, $methods, $ips, $attributes, null, $port];
  872.         while (\count($arguments) > 0 && !end($arguments)) {
  873.             array_pop($arguments);
  874.         }
  876.         $container
  877.             ->register($id, 'Symfony\Component\HttpFoundation\RequestMatcher')
  878.             ->setPublic(false)
  879.             ->setArguments($arguments)
  880.         ;
  882.         return $this->requestMatchers[$id] = new Reference($id);
  883.     }
  885.     public function addAuthenticatorFactory(AuthenticatorFactoryInterface $factory)
  886.     {
  887.         $this->factories[] = [$factory->getPriority(), $factory];
  888.         $this->sortedFactories = [];
  889.     }
  891.     public function addUserProviderFactory(UserProviderFactoryInterface $factory)
  892.     {
  893.         $this->userProviderFactories[] = $factory;
  894.     }
  896.     /**
  897.      * {@inheritdoc}
  898.      */
  899.     public function getXsdValidationBasePath(): string|false
  900.     {
  901.         return __DIR__.'/../Resources/config/schema';
  902.     }
  904.     public function getNamespace(): string
  905.     {
  906.         return 'http://symfony.com/schema/dic/security';
  907.     }
  909.     public function getConfiguration(array $config, ContainerBuilder $container): ?ConfigurationInterface
  910.     {
  911.         // first assemble the factories
  912.         return new MainConfiguration($this->getSortedFactories(), $this->userProviderFactories);
  913.     }
  915.     private function isValidIps(string|array $ips): bool
  916.     {
  917.         $ipsList = array_reduce((array) $ips, static function (array $ips, string $ip) {
  918.             return array_merge($ips, preg_split('/\s*,\s*/', $ip));
  919.         }, []);
  921.         if (!$ipsList) {
  922.             return false;
  923.         }
  925.         foreach ($ipsList as $cidr) {
  926.             if (!$this->isValidIp($cidr)) {
  927.                 return false;
  928.             }
  929.         }
  931.         return true;
  932.     }
  934.     private function isValidIp(string $cidr): bool
  935.     {
  936.         $cidrParts = explode('/', $cidr);
  938.         if (1 === \count($cidrParts)) {
  939.             return false !== filter_var($cidrParts[0], \FILTER_VALIDATE_IP);
  940.         }
  942.         $ip = $cidrParts[0];
  943.         $netmask = $cidrParts[1];
  945.         if (!ctype_digit($netmask)) {
  946.             return false;
  947.         }
  949.         if (filter_var($ip, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV4)) {
  950.             return $netmask <= 32;
  951.         }
  953.         if (filter_var($ip, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV6)) {
  954.             return $netmask <= 128;
  955.         }
  957.         return false;
  958.     }
  960.     /**
  961.      * @return array<int, AuthenticatorFactoryInterface>
  962.      */
  963.     private function getSortedFactories(): array
  964.     {
  965.         if (!$this->sortedFactories) {
  966.             $factories = [];
  967.             foreach ($this->factories as $i => $factory) {
  968.                 $factories[] = array_merge($factory, [$i]);
  969.             }
  971.             usort($factories, function ($a, $b) {
  972.                 return $b[0] <=> $a[0] ?: $a[2] <=> $b[2];
  973.             });
  975.             $this->sortedFactories = array_column($factories, 1);
  976.         }
  978.         return $this->sortedFactories;
  979.     }
  980. }