├── .atoum.php
├── .coke
├── .gitignore
├── .travis.yml
├── Annotation
    └── Firewall.php
├── Controller
    └── Listener.php
├── DependencyInjection
    ├── Configuration.php
    └── M6WebFirewallExtension.php
├── EventListener
    └── RequestListener.php
├── Firewall
    ├── Firewall.php
    ├── FirewallInterface.php
    ├── Provider.php
    └── ProviderInterface.php
├── LICENSE
├── M6WebFirewallBundle.php
├── README.md
├── Resources
    └── config
    │   └── services.yml
├── Tests
    ├── Units
    │   ├── Annotation
    │   │   └── Firewall.php
    │   ├── Controller
    │   │   └── Listener.php
    │   ├── DependencyInjection
    │   │   └── M6WebFirewallExtension.php
    │   ├── EventListener
    │   │   └── RequestListener.php
    │   └── Firewall
    │   │   └── Provider.php
    └── bootstrap.php
└── composer.json


/.atoum.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $runner->addTestsFromDirectory(__DIR__.'/Tests');
4 | 


--------------------------------------------------------------------------------
/.coke:
--------------------------------------------------------------------------------
 1 | # Configuration file for Coke, "Enjoy sniffing your code" : https://github.com/M6Web/Coke
 2 | 
 3 | # Command used to launch PHP CodeSniffer (optional - default: phpcs)
 4 | command=phpcs
 5 | 
 6 | # Standard used by PHP CodeSniffer (required)
 7 | standard=Symfony2
 8 | 
 9 | # Verbose mode (optional - default: false)
10 | verbose=true
11 | 
12 | # White list of files and directories (optional)
13 | Firewall/
14 | EventListener/
15 | Controller/
16 | Annotation/
17 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | composer.lock
2 | vendor
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 7.0
 5 |   - 7.1
 6 | 
 7 | before_script:
 8 |   - wget http://getcomposer.org/composer.phar
 9 |   - php -d memory_limit=1G composer.phar install
10 | 
11 | script:
12 |   - vendor/bin/atoum -d Tests
13 | 


--------------------------------------------------------------------------------
/Annotation/Firewall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace M6Web\Bundle\FirewallBundle\Annotation;
 3 | 
 4 | /**
 5 |  * Add a firewall before a controller or before one or more of its methods
 6 |  *
 7 |  * @author Jérémy JOURDIN <jjourdin.externe@m6.fr>
 8 |  *
 9 |  * @Annotation
10 |  */
11 | class Firewall
12 | {
13 |     /**
14 |      * @var string $config Name of the predefined configuration to use in the firewall
15 |      */
16 |     public $config;
17 | 
18 |     /**
19 |      * @var array $actions Controller methods where the firewall is applied
20 |      */
21 |     public $actions;
22 | 
23 |     /**
24 |      * @var array $options Firewall setting
25 |      */
26 |     public $options;
27 | 
28 |     /**
29 |      * Constructor, set the annotation data
30 |      *
31 |      * @param array $data Annotation data
32 |      */
33 |     public function __construct(array $data)
34 |     {
35 |         $this->config   = ( isset($data['config']) ? $data['config'] : null );
36 |         $this->actions  = ( isset($data['actions']) ? $data['actions'] : null );
37 |         $this->options  = array(
38 |             "entries"       => ( isset($data['entries'])       ? $data['entries']       : array() ),
39 |             "lists"         => ( isset($data['lists'])         ? $data['lists']         : array() ),
40 |             "callback"      => ( isset($data['callback'])      ? $data['callback']      : null ),
41 |             "default_state" => ( isset($data['default_state']) ? $data['default_state'] : null ),
42 |             "error_message" => ( isset($data['error_message']) ? $data['error_message'] : null ),
43 |             "error_code"    => ( isset($data['error_code'])    ? $data['error_code']    : null ),
44 |             "throw_error"   => ( isset($data['throw_error'])   ? $data['throw_error']   : null ),
45 |         );
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/Controller/Listener.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace M6Web\Bundle\FirewallBundle\Controller;
  3 | 
  4 | use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  5 | 
  6 | use Doctrine\Common\Annotations\Reader;
  7 | 
  8 | use M6Web\Bundle\FirewallBundle\Annotation\Firewall,
  9 |     M6Web\Bundle\FirewallBundle\Firewall\Provider;
 10 | 
 11 | /**
 12 |  * Listener of the controller events
 13 |  *
 14 |  * @author Jérémy JOURDIN <jjourdin.externe@m6.fr>
 15 |  */
 16 | class Listener
 17 | {
 18 |     /**
 19 |      * @var Reader $reader Doctrine annotation reader
 20 |      */
 21 |     protected $reader;
 22 | 
 23 |     /**
 24 |      * @var Provider $provider Firewall manager
 25 |      */
 26 |     protected $provider;
 27 | 
 28 |     /**
 29 |      * Constructor
 30 |      *
 31 |      * @param Reader   $reader   Doctrine annotation reader
 32 |      * @param Provider $provider Firewall manager
 33 |      */
 34 |     public function __construct(Reader $reader, Provider $provider)
 35 |     {
 36 |         $this->reader = $reader;
 37 |         $this->provider = $provider;
 38 |     }
 39 | 
 40 |     /**
 41 |      * Get the firewall manager
 42 |      *
 43 |      * @return Provider
 44 |      */
 45 |     public function getProvider()
 46 |     {
 47 |         return $this->provider;
 48 |     }
 49 | 
 50 |     /**
 51 |      * Get the annotation reader
 52 |      *
 53 |      * @return Reader
 54 |      */
 55 |     public function getReader()
 56 |     {
 57 |         return $this->reader;
 58 |     }
 59 | 
 60 |     /**
 61 |      * Event before action execution
 62 |      *
 63 |      * @param FilterControllerEvent $event Symfony trigger event
 64 |      */
 65 |     public function onCoreController(FilterControllerEvent $event)
 66 |     {
 67 |         if (!is_array($controller = $event->getController())) {
 68 |             return;
 69 |         }
 70 | 
 71 |         $class  = new \ReflectionClass($controller[0]);
 72 |         $method = $class->getMethod($controller[1]);
 73 | 
 74 |         if ($classAnnotations = $this->reader->getClassAnnotations($class)) {
 75 |             foreach ($classAnnotations as $classAnnotation) {
 76 |                 if ($classAnnotation instanceof Firewall) {
 77 |                     if (is_array($classAnnotation->actions) && in_array($method->name, $classAnnotation->actions)) {
 78 |                         $this->loadFirewall($classAnnotation);
 79 |                     } elseif ($classAnnotation->actions === null) {
 80 |                         $this->loadFirewall($classAnnotation);
 81 |                     }
 82 |                 }
 83 |             }
 84 |         }
 85 | 
 86 |         if ($methodAnnotation = $this->reader->getMethodAnnotation($method, 'M6Web\Bundle\FirewallBundle\Annotation\Firewall')) {
 87 |             $this->loadFirewall($methodAnnotation);
 88 |         }
 89 |     }
 90 | 
 91 |     /**
 92 |      * Load firewall with a configuration
 93 |      *
 94 |      * @param \M6Web\Bundle\FirewallBundle\Annotation\Firewall $annotation Annotation with configuration data
 95 |      */
 96 |     protected function loadFirewall($annotation)
 97 |     {
 98 |         $firewall = $this->provider->getFirewall($annotation->config, $annotation->options);
 99 |         $firewall->handle($annotation->options['callback']);
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/DependencyInjection/Configuration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace M6Web\Bundle\FirewallBundle\DependencyInjection;
 3 | 
 4 | use Symfony\Component\Config\Definition\Builder\TreeBuilder,
 5 |     Symfony\Component\Config\Definition\ConfigurationInterface;
 6 | use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
 7 | 
 8 | /**
 9 |  * This is the class that validates and merges configuration from your app/config files
10 |  *
11 |  * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html#cookbook-bundles-extension-config-class}
12 |  */
13 | class Configuration implements ConfigurationInterface
14 | {
15 |     /**
16 |      * {@inheritDoc}
17 |      */
18 |     public function getConfigTreeBuilder()
19 |     {
20 |         $treeBuilder = new TreeBuilder();
21 |         $rootNode = $treeBuilder->root('m6web_firewall');
22 | 
23 |         $rootNode
24 |             ->children()
25 |                 // Add pre-defined configs management
26 |                 ->arrayNode('configs')
27 |                     ->useAttributeAsKey('name')
28 |                     ->prototype('array')
29 |                         ->fixXmlConfig('list', 'lists')
30 |                         ->fixXmlConfig('entry', 'entries')
31 |                         ->children()
32 |                             // Set firewall default state
33 |                             ->booleanNode('default_state')->defaultFalse()->end()
34 |                             ->scalarNode('error_code')->end()
35 |                             ->scalarNode('error_message')->end()
36 |                             ->booleanNode('throw_error')->defaultTrue()->end()
37 |                             // Set pre-defined list status
38 |                             ->arrayNode('lists')
39 |                                 ->useAttributeAsKey('name')
40 |                                 ->prototype('boolean')->defaultFalse()->end()
41 |                             ->end()
42 |                             // Set single entries status
43 |                             ->arrayNode('entries')
44 |                                 ->useAttributeAsKey('template')
45 |                                 ->prototype('boolean')->defaultFalse()->end()
46 |                             ->end()
47 |                         ->end()
48 |                     ->end()
49 |                 ->end()
50 |                 // Add pre-defined lists management
51 |                 ->arrayNode('lists')
52 |                     ->useAttributeAsKey('name')
53 |                     ->prototype('array')
54 |                         ->prototype('variable')
55 |                             ->validate()
56 |                                 ->always(function ($list) {
57 |                                     if (!is_array($list) && !is_string($list)) {
58 |                                         throw new InvalidConfigurationException('Invalid configuration for path "m6web_firewall.lists": lists are any depth arrays of string values');
59 |                                     }
60 |                                     
61 |                                     return $list;
62 |                                 })
63 |                             ->end()
64 |                             ->cannotBeEmpty()
65 |                         ->end()
66 |                     ->end()
67 |                 ->end()
68 |                 // Add pattern support
69 |                 ->arrayNode('patterns')
70 |                     ->useAttributeAsKey('name')
71 |                     ->prototype('array')
72 |                         ->children()
73 |                             ->scalarNode('config')->end()
74 |                             ->scalarNode('path')->end()
75 |                         ->end()
76 |                     ->end()
77 |                 ->end()
78 |             ->end();
79 | 
80 |         return $treeBuilder;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/DependencyInjection/M6WebFirewallExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace M6Web\Bundle\FirewallBundle\DependencyInjection;
 3 | 
 4 | use Symfony\Component\DependencyInjection\ContainerBuilder,
 5 |     Symfony\Component\Config\FileLocator,
 6 |     Symfony\Component\HttpKernel\DependencyInjection\Extension,
 7 |     Symfony\Component\DependencyInjection\Loader;
 8 | 
 9 | /**
10 |  * This is the class that loads and manages your bundle configuration
11 |  *
12 |  * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html}
13 |  */
14 | class M6WebFirewallExtension extends Extension
15 | {
16 |     /**
17 |      * {@inheritDoc}
18 |      */
19 |     public function load(array $configs, ContainerBuilder $container)
20 |     {
21 |         $this->flatLists($configs);
22 | 
23 |         $configuration = new Configuration();
24 |         $config = $this->processConfiguration($configuration, $configs);
25 | 
26 |         $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
27 |         $loader->load('services.yml');
28 | 
29 |         if (!empty($config['configs']) ) {
30 |             $this->configsLoad($config['configs'], $container);
31 |         }
32 | 
33 |         if (!empty($config['lists']) ) {
34 |             $this->listsLoad($config['lists'], $container);
35 |         }
36 | 
37 |         if (!empty($config['patterns']) ) {
38 |             $this->patternsLoad($config['patterns'], $container);
39 |         }
40 |     }
41 | 
42 |     protected function configsLoad(array $config, ContainerBuilder $container)
43 |     {
44 |         $container->setParameter('m6web.firewall.configs', $config);
45 |     }
46 | 
47 |     protected function listsLoad(array $config, ContainerBuilder $container)
48 |     {
49 |         $container->setParameter('m6web.firewall.lists', $config);
50 |     }
51 | 
52 |     protected function patternsLoad(array $config, ContainerBuilder $container)
53 |     {
54 |         $container->setParameter('m6web.firewall.patterns', $config);
55 |     }
56 | 
57 |     protected function flatLists(array &$configs)
58 |     {
59 |         foreach ($configs as &$config) {
60 |             if (isset($config['lists'])) {
61 |                 foreach ($config['lists'] as &$list) {
62 |                     $this->flatList($list);
63 |                 }
64 |             }
65 |         }
66 | 
67 |         return $configs;
68 |     }
69 | 
70 |     protected function flatList(array &$list)
71 |     {
72 |         $return = array();
73 |         array_walk_recursive($list, function($a) use (&$return) {
74 |             $return[] = $a;
75 |         });
76 |         $list = $return;
77 | 
78 |         return $list;
79 |     }
80 | 
81 |     public function getAlias()
82 |     {
83 |         return 'm6web_firewall';
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/EventListener/RequestListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace M6Web\Bundle\FirewallBundle\EventListener;
 4 | 
 5 | use Symfony\Component\HttpKernel\Bundle\Bundle;
 6 | use Symfony\Component\HttpKernel\Event\GetResponseEvent;
 7 | use Symfony\Component\HttpKernel\HttpKernelInterface;
 8 | use M6Web\Bundle\FirewallBundle\Firewall\ProviderInterface;
 9 | 
10 | /**
11 |  * class RequestListener
12 |  */
13 | class RequestListener extends Bundle
14 | {
15 |     /**
16 |     * firewall provider
17 |     */
18 |     protected $provider;
19 | 
20 |     /**
21 |     * @param provider $provider firewall provider
22 |     */
23 |     public function __construct(ProviderInterface $provider)
24 |     {
25 |         $this->provider = $provider;
26 |     }
27 | 
28 |     /**
29 |     * on request event
30 |     * @param GetResponseEvent $event event
31 |     */
32 |     public function onRequest(GetResponseEvent $event)
33 |     {
34 |         if (HttpKernelInterface::MASTER_REQUEST !== $event->getRequestType()) {
35 |             return;
36 |         }
37 |         $patterns = $this->provider->getPatterns();
38 |         if ($patterns) {
39 |             foreach ($patterns as $pattern) {
40 |                 if ($pattern['matcher']->matches($event->getRequest())) {
41 |                    $firewall = $this->provider->getFirewall($pattern['config']);
42 |                    $firewall->handle();
43 |                 }
44 |             }
45 |         }
46 |     }
47 | 
48 | }
49 | 


--------------------------------------------------------------------------------
/Firewall/Firewall.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace M6Web\Bundle\FirewallBundle\Firewall;
  3 | 
  4 | use Symfony\Component\HttpFoundation\Request,
  5 |     Symfony\Component\HttpKernel\Exception\HttpException;
  6 | 
  7 | use M6Web\Component\Firewall\Firewall as FirewallComponent;
  8 | 
  9 | /**
 10 |  * {@inheritdoc}
 11 |  */
 12 | class Firewall extends FirewallComponent implements FirewallInterface
 13 | {
 14 |     /**
 15 |      * @var Provider $provider Firewall manager
 16 |      */
 17 |     protected $provider;
 18 | 
 19 |     /**
 20 |      * @var Request $request Symfony request
 21 |      */
 22 |     protected $request;
 23 | 
 24 |     /**
 25 |      * @var boolean $throwError Throw exception if the input is invalid
 26 |      */
 27 |     protected $throwError = true;
 28 | 
 29 |     /**
 30 |      * @var integer $errorCode Error code to return for invalid input
 31 |      */
 32 |     protected $errorCode = 403;
 33 | 
 34 |     /**
 35 |      * @var string $errorMessage Error message to return for invalid input
 36 |      */
 37 |     protected $errorMessage = 'Forbidden';
 38 | 
 39 |     /**
 40 |      * {@inheritdoc}
 41 |      */
 42 |     public function setProvider(Provider $provider)
 43 |     {
 44 |         $this->provider = $provider;
 45 | 
 46 |         return $this;
 47 |     }
 48 | 
 49 |     /**
 50 |      * {@inheritdoc}
 51 |      */
 52 |     public function setRequest(Request $request)
 53 |     {
 54 |         $this->request = $request;
 55 | 
 56 |         return $this;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Add/remove a predefined list in the firewall
 61 |      *
 62 |      * @param string       $listName List name
 63 |      * @param boolean|null $state    List state in the firewall (true=white, false=black, null=undefined)
 64 |      *
 65 |      * @return $this
 66 |      */
 67 |     public function setPresetList($listName, $state=null)
 68 |     {
 69 |         $lists = $this->provider->getLists();
 70 | 
 71 |         if (is_array($listName)) {
 72 |             foreach ($listName as $list) {
 73 |                 $this->setPresetList($list, $state);
 74 |             }
 75 |         } else {
 76 |             parent::setList($lists[$listName], $listName, $state);
 77 |         }
 78 | 
 79 |         return $this;
 80 |     }
 81 | 
 82 |     /**
 83 |      * Set a list as "black" (banned)
 84 |      *
 85 |      * @param string $listName List name
 86 |      *
 87 |      * @return $this
 88 |      */
 89 |     public function setListBlack($listName)
 90 |     {
 91 |         $this->setPresetList($listName, false);
 92 | 
 93 |         return $this;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Set a list as "white" (allowed)
 98 |      *
 99 |      * @param string $listName List name
100 |      *
101 |      * @return $this
102 |      */
103 |     public function setListWhite($listName)
104 |     {
105 |         $this->setPresetList($listName, true);
106 | 
107 |         return $this;
108 |     }
109 | 
110 |     /**
111 |      * {@inheritdoc}
112 |      */
113 |     public function setErrorCode($code)
114 |     {
115 |         if (is_int($code) || ctype_digit($code)) {
116 |             $this->errorCode = (int) $code;
117 |         }
118 | 
119 |         return $this;
120 |     }
121 | 
122 |     /**
123 |      * Get the error code
124 |      *
125 |      * @return integer
126 |      */
127 |     public function getErrorCode()
128 |     {
129 |         return $this->errorCode;
130 |     }
131 | 
132 |     /**
133 |      * {@inheritdoc}
134 |      */
135 |     public function setErrorMessage($message)
136 |     {
137 |         $this->errorMessage = (string) $message;
138 | 
139 |         return $this;
140 |     }
141 | 
142 |     /**
143 |      * Get the error message
144 |      *
145 |      * @return string
146 |      */
147 |     public function getErrorMessage()
148 |     {
149 |         return $this->errorMessage;
150 |     }
151 | 
152 |     /**
153 |      * {@inheritdoc}
154 |      */
155 |     public function setThrowError($throw)
156 |     {
157 |         if (is_bool($throw)) {
158 |             $this->throwError = $throw;
159 |         } else {
160 |             throw new \InvalidArgumentException(sprintf("Firewall::setThrowError() Arg#1 must be a boolean, %s given.", gettype($throw)));
161 |         }
162 | 
163 |         return $this;
164 |     }
165 | 
166 |     /**
167 |      * Check if an exception is throwed in error case
168 |      *
169 |      * @return boolean
170 |      */
171 |     public function isThrowError()
172 |     {
173 |         return $this->throwError;
174 |     }
175 | 
176 |     /**
177 |      * {@inheritdoc}
178 |      *
179 |      * @throws HttpException If input is invalid and $throwError = true
180 |      */
181 |     public function handle(callable $callBack = null)
182 |     {
183 |         $ipAddress = $this->request->getClientIp();
184 | 
185 |         $this->setIpAddress($ipAddress);
186 | 
187 |         $isAllowed = parent::handle($callBack);
188 | 
189 |         if (!$isAllowed && $this->throwError) {
190 |             throw new HttpException($this->errorCode, sprintf('%s [ip: %s]', $this->errorMessage, $ipAddress));
191 |         }
192 | 
193 |         return $isAllowed;
194 |     }
195 | }
196 | 


--------------------------------------------------------------------------------
/Firewall/FirewallInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace M6Web\Bundle\FirewallBundle\Firewall;
 3 | 
 4 | use Symfony\Component\HttpFoundation\Request;
 5 | 
 6 | /**
 7 |  * Class FirewallInterface
 8 |  *
 9 |  * @package M6Web\Bundle\FirewallBundle\Firewall
10 |  */
11 | interface FirewallInterface
12 | {
13 |     /**
14 |      * Set the firewall provider
15 |      *
16 |      * @param Provider $provider Firewall manager
17 |      *
18 |      * @return $this
19 |      */
20 |     public function setProvider(Provider $provider);
21 | 
22 |     /**
23 |      * Set the contextual request
24 |      *
25 |      * @param Request $request Symfony request
26 |      *
27 |      * @return $this
28 |      */
29 |     public function setRequest(Request $request);
30 | 
31 |     /**
32 |      * Handle the current request
33 |      *
34 |      * @param callable $callBack Result handler
35 |      *
36 |      * @return boolean
37 |      */
38 |     public function handle(callable $callBack = null);
39 | 
40 |     /**
41 |      * Get Client IP
42 |      *
43 |      * @return string
44 |      */
45 |     public function getIpAddress();
46 | 
47 |     /**
48 |      * Add a list
49 |      *
50 |      * @param array        $list     List
51 |      * @param string       $listName Identifier for the list
52 |      * @param boolean|null $state    Whether the list is trusted or not
53 |      *
54 |      * @return $this
55 |      */
56 |     public function addList(array $list, $listName, $state);
57 | 
58 |     /**
59 |      * Set default returned value
60 |      *
61 |      * @param boolean $state Default returned value
62 |      *
63 |      * @return $this
64 |      */
65 |     public function setDefaultState($state);
66 | 
67 |     /**
68 |      * Set the error code
69 |      *
70 |      * @param integer $code Error code
71 |      *
72 |      * @return $this
73 |      */
74 |     public function setErrorCode($code);
75 | 
76 |     /**
77 |      * Set the error message
78 |      *
79 |      * @param string $message Error message
80 |      *
81 |      * @return $this
82 |      */
83 |     public function setErrorMessage($message);
84 | 
85 |     /**
86 |      * Activate/Disable the exception throw
87 |      *
88 |      * @param boolean $throw Throw or not an exception in error case
89 |      *
90 |      * @return $this
91 |      */
92 |     public function setThrowError($throw);
93 | }
94 | 


--------------------------------------------------------------------------------
/Firewall/Provider.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace M6Web\Bundle\FirewallBundle\Firewall;
  3 | 
  4 | use Symfony\Component\HttpFoundation\Request;
  5 | use Symfony\Component\DependencyInjection\ContainerInterface;
  6 | use Symfony\Component\HttpFoundation\RequestMatcher;
  7 | 
  8 | /**
  9 |  * Firewall manager
 10 |  * Get a default firewall instance or with a predefined configuration
 11 |  *
 12 |  * @author Jérémy Jourdin <jjourdin.externe@m6.fr>
 13 |  */
 14 | class Provider implements ProviderInterface
 15 | {
 16 |     /**
 17 |      * @var array|null $lists Lists of predefined named ip
 18 |      */
 19 |     protected $lists;
 20 | 
 21 |     /**
 22 |      * @var array|null $configs Predefined configurations
 23 |      */
 24 |     protected $configs;
 25 | 
 26 |     /**
 27 |      * @var array|null $configs Predefined patterns
 28 |      */
 29 |     protected $patterns;
 30 | 
 31 |     /**
 32 |      * @var string $firewallClass Class for firewall objects
 33 |      */
 34 |     protected $firewallClass = 'M6Web\Bundle\FirewallBundle\Firewall\Firewall';
 35 | 
 36 |     /**
 37 |      * @var array $configModel Configuration model use to format configuration
 38 |      */
 39 |     protected $configModel = array(
 40 |         "default_state" => array(
 41 |             "default" => null,
 42 |             "method"  => "setDefaultState",
 43 |         ),
 44 |         "error_message" => array(
 45 |             "default" => null,
 46 |             "method"  =>"setErrorMessage",
 47 |         ),
 48 |         "error_code" => array(
 49 |             "default" => null,
 50 |             "method"  =>"setErrorCode",
 51 |         ),
 52 |         "throw_error" => array(
 53 |             "default" => null,
 54 |             "method"  =>"setThrowError",
 55 |         ),
 56 |         "lists" => array(
 57 |             "default" => null,
 58 |         ),
 59 |         "entries" => array(
 60 |             "default" => array(),
 61 |         ),
 62 |     );
 63 | 
 64 |     /**
 65 |      * @var array $firewalls Activated firewalls
 66 |      */
 67 |     protected $firewalls = array();
 68 | 
 69 |     /**
 70 |      * @var ContainerInterface $container Service container
 71 |      */
 72 |     protected $container;
 73 | 
 74 |     /**
 75 |      * Constructor
 76 |      *
 77 |      * @param ContainerInterface $container Service container
 78 |      * @param array              $lists     Lists of predefined ip
 79 |      * @param array              $configs   Predefined configurations
 80 |      * @param string             $patterns  Pattern
 81 |      */
 82 |     public function __construct(ContainerInterface $container, array $lists = null, array $configs = null, $patterns = null)
 83 |     {
 84 |         $this->lists        = $lists;
 85 |         $this->container    = $container;
 86 | 
 87 |         if (!empty($configs)) {
 88 |             foreach ($configs as $configName => $config) {
 89 |                 $this->loadConfig($configName, $config);
 90 |             }
 91 |         }
 92 | 
 93 |         if (!empty($patterns)) {
 94 |             foreach ($patterns as $patternName => $pattern) {
 95 |                 $this->loadPattern($patternName, $pattern);
 96 |             }
 97 |         }
 98 |     }
 99 | 
100 |     /**
101 |      * Load a formated configuration
102 |      *
103 |      * @param string $configName Configuration name in $this->configs
104 |      * @param array  $config     Configuration data
105 |      *
106 |      * @return $this
107 |      */
108 |     protected function loadConfig($configName, array $config)
109 |     {
110 |         $this->configs[$configName] = $this->normalizeConfig($config);
111 | 
112 |         return $this;
113 |     }
114 | 
115 |     /**
116 |      * Load a formated pattern
117 |      *
118 |      * @param string $patternName Patern  name in $this->patterns
119 |      * @param array  $pattern     Pattern data
120 |      *
121 |      * @return $this
122 |      */
123 |     protected function loadPattern($patternName, array $pattern)
124 |     {
125 |         $pattern['matcher'] = new RequestMatcher($pattern['path']);
126 | 
127 |         $this->patterns[$patternName] = $pattern;
128 | 
129 |         return $this;
130 |     }
131 | 
132 |     /**
133 |      * Format an array of configurations with the model
134 |      *
135 |      * @param array $config Base configurations
136 |      *
137 |      * @return array Formated configurations
138 |      */
139 |     protected function normalizeConfig(array $config)
140 |     {
141 |         foreach ($this->configModel as $elmt => $settings) {
142 |             if (!isset($config[$elmt])) {
143 |                 $config[$elmt] = $settings['default'];
144 |             }
145 |         }
146 | 
147 |         foreach ($config as $elmtName => $value) {
148 |             if (!isset($this->configModel[$elmtName])) {
149 |                 unset($config[$elmtName]);
150 |             }
151 |         }
152 | 
153 |         return $config;
154 |     }
155 | 
156 |     /**
157 |      * Get a firewall set with a predefined configuration or with additional setting
158 |      *
159 |      * @param string|null $configName Predefined configuration name
160 |      * @param array       $options    Additional setting
161 |      * @param Request     $request    Request
162 |      *
163 |      * @return FirewallInterface
164 |      */
165 |     public function getFirewall($configName = null, array $options = array(), Request $request = null)
166 |     {
167 |         if (!$request) {
168 |             if ($this->container->has('request_stack')) {
169 |                 $requestStack = $this->container->get('request_stack');
170 |                 $request = $requestStack->getCurrentRequest();
171 |             } elseif ($this->container->has('request')) {
172 |                 $request = $this->container->get('request');
173 |             } else {
174 |                 throw new \Exception('Request object undefined');
175 |             }
176 |         }
177 | 
178 |         $firewall = new $this->firewallClass();
179 |         $firewall->setProvider($this);
180 |         $firewall->setRequest($request);
181 | 
182 |         $this->setDefaults($firewall, $configName, $options);
183 | 
184 |         $this->firewalls[] = $firewall;
185 | 
186 |         return $firewall;
187 |     }
188 | 
189 |     /**
190 |      * Set the firewall class
191 |      *
192 |      * @param string $firewallClass Class for firewall objects
193 |      *
194 |      * @return $this
195 |      */
196 |     public function setFirewallClass($firewallClass)
197 |     {
198 |         $this->firewallClass = $firewallClass;
199 | 
200 |         return $this;
201 |     }
202 | 
203 |     /**
204 |      * Get lists of predefined ip
205 |      *
206 |      * @return array
207 |      */
208 |     public function getLists()
209 |     {
210 |         return $this->lists;
211 |     }
212 | 
213 |     /**
214 |      * get predefined configuration
215 |      *
216 |      * @return array
217 |      */
218 |     public function getConfigs()
219 |     {
220 |         return $this->configs;
221 |     }
222 | 
223 |     /**
224 |      * get predefined patterns
225 |      *
226 |      * @return array
227 |      */
228 |     public function getPatterns()
229 |     {
230 |         return $this->patterns;
231 |     }
232 | 
233 |     /**
234 |      * Configure a firewall
235 |      *
236 |      * @param FirewallInterface $firewall   Firewall
237 |      * @param string            $configName Predefined configuration name
238 |      * @param array             $options    Additional setting
239 |      *
240 |      * @return $this
241 |      */
242 |     protected function setDefaults(FirewallInterface $firewall, $configName = null, array $options = array())
243 |     {
244 |         $config = $this->getNormalizedConfig($configName);
245 | 
246 |         $this->mergeOptions($config, $options);
247 | 
248 |         foreach ($config as $paramName => $paramValue) {
249 |             $this->setDefault($firewall, $paramName, $paramValue, $config);
250 |         }
251 | 
252 |         return $this;
253 |     }
254 | 
255 |     /**
256 |      * Set a default value for a configuration parameter
257 |      *
258 |      * @param Firewall $firewall Firewall
259 |      * @param string   $param    Parameter name
260 |      * @param string   $value    Parameter value
261 |      * @param array    $config   Reference to the configuration
262 |      *
263 |      * @return $this
264 |      */
265 |     protected function setDefault(FirewallInterface $firewall, $param, $value, $config)
266 |     {
267 |         $configModel = $this->configModel[$param];
268 | 
269 |         switch ($param) {
270 |             case 'lists':
271 |                 if (is_array($value)) {
272 |                     $this->setDefaultLists($firewall, $value);
273 |                 }
274 |                 break;
275 |             case 'entries':
276 |                 $this->setEntries($firewall, $config, $value);
277 |                 break;
278 |             default:
279 |                 if (!is_null($value)) {
280 |                     $method = $configModel['method'];
281 |                     $firewall->$method($value);
282 |                 }
283 |         }
284 | 
285 |         return $this;
286 |     }
287 | 
288 |     /**
289 |      * Set the default lists of the firewall
290 |      *
291 |      * @param FirewallInterface $firewall Firewall
292 |      * @param array             $lists    Input lists
293 |      *
294 |      * @return $this
295 |      */
296 |     protected function setDefaultLists(FirewallInterface $firewall, array $lists)
297 |     {
298 |         foreach ($lists as $listName => $state) {
299 |             if (isset($this->lists[$listName])) {
300 |                 $list = $this->lists[$listName];
301 |                 $firewall->addList($list, $listName, $state);
302 |             } else {
303 |                 throw new \Exception(sprintf('Firewall list "%s" not found.', $listName));
304 |             }
305 |         }
306 | 
307 |         return $this;
308 |     }
309 | 
310 |     /**
311 |      * Set up firewall lists from independent input
312 |      *
313 |      * @param FirewallInterface $firewall Firewall interface
314 |      * @param array             $config   Reference to the configuration
315 |      *
316 |      * @return $this
317 |      */
318 |     protected function setEntries(FirewallInterface $firewall, $config)
319 |     {
320 |         $entries = (isset($config['entries']) ? $config['entries'] : array());
321 | 
322 |         $blackEntries = array_keys($entries, false);
323 |         $whiteEntries = array_keys($entries, true);
324 | 
325 |         if (count($blackEntries)) {
326 |             $firewall->addList($blackEntries, 'blackedOptions', false);
327 |         }
328 | 
329 |         if (count($whiteEntries)) {
330 |             $firewall->addList($whiteEntries, 'whitedOptions', true);
331 |         }
332 | 
333 |         return $this;
334 |     }
335 | 
336 |     /**
337 |      * Get the normalized configuration
338 |      *
339 |      * @param string|null $configName Configuration name
340 |      *
341 |      * @throws Exception If the configuration name is unknown
342 |      *
343 |      * @return array Normalized configuration
344 |      */
345 |     protected function getNormalizedConfig($configName = null)
346 |     {
347 |         if (isset($this->configs[$configName])) {
348 |             $config = $this->configs[$configName];
349 |         } elseif ($configName === null) {
350 |             $arr = array();
351 |             $config = $this->normalizeConfig($arr);
352 |         } else {
353 |             throw new \Exception(sprintf('Firewall configuration "%s" not found.', $configName));
354 |         }
355 | 
356 |         return $config;
357 |     }
358 | 
359 |     /**
360 |      * Include on the fly generated options in the main configuration
361 |      *
362 |      * @param array &$config Reference to the configuration
363 |      * @param array $options Options
364 |      *
365 |      * @return array Full configuration
366 |      */
367 |     protected function mergeOptions(&$config, $options)
368 |     {
369 |         foreach ($config as $paramName => $paramValue) {
370 |             if (isset($options[$paramName])) {
371 |                 if (is_array($paramValue)) {
372 |                     $config[$paramName] =  array_merge($config[$paramName], $options[$paramName]);
373 |                 } else {
374 |                     $config[$paramName] = $options[$paramName];
375 |                 }
376 |             }
377 |         }
378 | 
379 |         return $config;
380 |     }
381 | }
382 | 


--------------------------------------------------------------------------------
/Firewall/ProviderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace M6Web\Bundle\FirewallBundle\Firewall;
 3 | 
 4 | use Symfony\Component\HttpFoundation\Request;
 5 | 
 6 | /**
 7 |  * Interface for Firewall manager
 8 |  */
 9 | interface ProviderInterface
10 | {
11 |      /**
12 |      * Get a firewall set with a predefined configuration or with additional setting
13 |      *
14 |      * @param string|null $configName Predefined configuration name
15 |      * @param array       $options    Additional setting
16 |      * @param Request     $request    Request
17 |      *
18 |      * @return FirewallInterface
19 |      */
20 |     public function getFirewall($configName = null, array $options = array(), Request $request = null);
21 | 
22 |     /**
23 |      * get predefined patterns
24 |      *
25 |      * @return array
26 |      */
27 |     public function getPatterns();
28 | }
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 M6Web
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is furnished
 8 | to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/M6WebFirewallBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace M6Web\Bundle\FirewallBundle;
 4 | 
 5 | use Symfony\Component\HttpKernel\Bundle\Bundle;
 6 | 
 7 | /**
 8 |  * class FirewallBundle
 9 |  */
10 | class M6WebFirewallBundle extends Bundle
11 | {
12 |     public function getContainerExtension()
13 |     {
14 |         return new DependencyInjection\M6WebFirewallExtension();
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Firewall Bundle [![Build Status](https://secure.travis-ci.org/M6Web/FirewallBundle.png)](http://travis-ci.org/M6Web/FirewallBundle)
  2 | 
  3 | This bundle provides IP filtering features for your Symfony applications.  
  4 | It uses the [Firewall component](https://github.com/M6Web/Firewall) and offers service and annotations configuration.
  5 | 
  6 | For implementation into a Symfony 3 or Symfony 4 application, please use the release `v3.0.0` at least.
  7 | 
  8 | ## Installation
  9 | 
 10 | Add this line in your `composer.json` :
 11 | 
 12 | ```json
 13 | {
 14 |     "require": {
 15 |         "m6web/firewall-bundle": "dev-master"
 16 |     }
 17 | }
 18 | ```
 19 | 
 20 | Update your vendors :
 21 | 
 22 | ```
 23 | composer update m6web/firewall-bundle
 24 | ```
 25 | 
 26 | ## Registering
 27 | 
 28 | ```php
 29 | class AppKernel extends \Symfony\Component\HttpKernel\Kernel
 30 | {
 31 |     public function registerBundles()
 32 |     {
 33 |         $bundles = array(
 34 |             new M6Web\Bundle\FirewallBundle\M6WebFirewallBundle(),
 35 |         );
 36 |     }
 37 | }
 38 | ```
 39 | 
 40 | ## Usage
 41 | 
 42 | #### Configuration
 43 | 
 44 | ```yaml
 45 | m6web_firewall:
 46 |     lists:             	                   # Define some IP lists into the Firewall Provider
 47 |         self: 				                    # Define a list named "self"
 48 |             - '127.0.0.1' 			                # IPV4
 49 |             - '::1'      	 	        	        # IPV6 short notation
 50 |         lan:     			                    # Define a list named "lan"
 51 |             - '192.168.0.*' 		                # IPV4 with Wildcard (* = all)
 52 |             - '192.168.0.0/24' 		                # IPV4 with CIDR Mask
 53 |             - '192.168.0.0/255.255.255.0' 	        # IPV4 with Subnet Mask
 54 |     configs: 				               # Define some pre-defined configurations into the Firewall Provider
 55 |         default: 				                # Define a configuration named "default"
 56 |             default_state: true 		            # Default returned value (default: true)
 57 |             throw_error: true 		                # Throw an exception for rejected users (default: true)
 58 |             error_code: 403 		                # Exception status code (default: 403)
 59 |             error_message: 'Forbidden' 	            # Exception message (default: Forbidden)
 60 |             lists: 			                        # Lists access state
 61 |                 self: true 			                    # "self" list records will be allowed by the firewall
 62 |                 lan: false 			                    # "lan" list records will be rejected by the firewall
 63 |             entries: 			                    # Define custom IP's access state
 64 |                 '192.168.0.10': true 	                # "192.168.0.10" will be allowed
 65 |                 '192.168.0.20': false 	                # "192.168.0.20" will be rejected
 66 | ```
 67 | 
 68 | #### Global annotation
 69 | 
 70 | ```php
 71 | use M6Web\Bundle\FirewallBundle\Annotation\Firewall;
 72 | 
 73 | /**
 74 |  * @Firewall(
 75 |  *      config="default",
 76 |  *      actions={
 77 |  *          'myFirstAction'
 78 |  *      },
 79 |  *      default_state=true,
 80 |  *      lists={
 81 |  *          'default': true
 82 |  *      },
 83 |  *      entries={
 84 |  *          '192.168.0.50': false
 85 |  *      },
 86 |  *      throw_error: false,
 87 |  *      callback="myFirewallResponseHandler",
 88 |  *      error_message: 'Forbiden',
 89 |  *      error_code: 403
 90 |  * )
 91 |  */
 92 | ```
 93 | 
 94 | * `config` parameter sets which pre-defined configuration to use,  
 95 | * `actions` parameter sets which actions of the controller are protected (in case of Class Annotation).
 96 | 
 97 | All default [set](#configuration) parameters can be overloaded by annotation.
 98 | 
 99 | #### Class annotation
100 | 
101 | ```php
102 | use M6Web\Bundle\FirewallBundle\Annotation\Firewall;
103 | 
104 | /**
105 |  * @Firewall(
106 |  *      config="default",
107 |  *      actions={
108 |  *          'myFirstAction'
109 |  *      }
110 |  * )
111 |  */
112 | class MyBundleController extends Controller
113 | {
114 |     public function myFirstAction()
115 |     {
116 |     }
117 | 
118 |     public function mySecondAction()
119 |     {
120 |     }
121 | }
122 | ```
123 | 
124 | * `myFirstAction` is protected by the [pre-defined configuration](#configuration) `default`.  
125 | In this case we can set one (or many) firewall used for many actions.
126 | 
127 | #### Method annotation
128 | 
129 | ```php
130 | use M6Web\Bundle\FirewallBundle\Annotation\Firewall;
131 | 
132 | class MyBundleController extends Controller
133 | {
134 |     /**
135 |      * @Firewall(
136 |      *      config="default"
137 |      * )
138 |      */
139 |     public function myFirstAction()
140 |     {
141 |     }
142 | 
143 |     /**
144 |      * @Firewall(
145 |      *      default_state=true,
146 |      *      lists={
147 |      *           'lan': false
148 |      *      },
149 |      *      entries={
150 |      *          '20.30.40.50': false
151 |      *      }
152 |      * )
153 |      */
154 |     public function mySecondAction()
155 |     {
156 |     }
157 | }
158 | ```
159 | 
160 | * `myFirstAction` uses its own firewall with [pre-defined configuration](#configuration) `default`,
161 | * `mySecondAction` uses its own firewall with a custom configuration.
162 | 
163 | #### Path configuration
164 | 
165 | ```yaml
166 | m6web_firewall:
167 |     patterns:                             # define some routing pattern to filter
168 |         api:
169 |             config: default                         # config associed to the path
170 |             path: /api                              # path to filter
171 | ```
172 | 
173 | * `config` parameter sets which pre-defined configuration to use,  
174 | * `path` parameter sets which path are protected.
175 | 
176 | ## Running the tests
177 | 
178 | ```
179 | $ php composer.phar install --dev
180 | $ ./vendor/bin/atoum -d Tests/
181 | ```
182 | 
183 | ## Credits
184 | 
185 | Developped by the [Cytron Team](http://cytron.fr/) of [M6 Web](http://tech.m6web.fr/).  
186 | Tested with [atoum](http://atoum.org).
187 | 
188 | ## License
189 | 
190 | The FirewallBundle is licensed under the [MIT license](LICENSE).
191 | 


--------------------------------------------------------------------------------
/Resources/config/services.yml:
--------------------------------------------------------------------------------
 1 | parameters:
 2 |     m6web.firewall.lists:    ~
 3 |     m6web.firewall.configs:  ~
 4 |     m6web.firewall.patterns: ~
 5 |     m6web.firewall.class:    M6Web\Bundle\FirewallBundle\Firewall\Firewall
 6 | 
 7 | services:
 8 |     m6web.firewall.provider:
 9 |         class: M6Web\Bundle\FirewallBundle\Firewall\Provider
10 |         arguments: ["@service_container", "%m6web.firewall.lists%", "%m6web.firewall.configs%", "%m6web.firewall.patterns%"]
11 |         calls:
12 |             - ['setFirewallClass', ["%m6web.firewall.class%"]]
13 | 
14 |     m6web.firewall.controller_listener:
15 |         class: M6Web\Bundle\FirewallBundle\Controller\Listener
16 |         tags:
17 |           - { name: kernel.event_listener, event: kernel.controller, method: onCoreController, priority: -255 } 
18 |         arguments: ["@annotation_reader", "@m6web.firewall.provider"]
19 | 
20 |     m6web.firewall.request_listener:
21 |         class: M6Web\Bundle\FirewallBundle\EventListener\RequestListener
22 |         tags:
23 |           - { name: kernel.event_listener, event: kernel.request, method: onRequest, priority: -255 } 
24 |         arguments: ["@m6web.firewall.provider"]
25 | 


--------------------------------------------------------------------------------
/Tests/Units/Annotation/Firewall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace M6Web\Bundle\FirewallBundle\Tests\Units\Annotation;
 3 | 
 4 | require_once __DIR__.'/../../bootstrap.php';
 5 | 
 6 | use atoum\AtoumBundle\Test\Units;
 7 | 
 8 | use M6Web\Bundle\FirewallBundle\Annotation\Firewall as FirewallAnnotation;
 9 | 
10 | /**
11 |  * Firewall annotation class test
12 |  */
13 | class Firewall extends Units\Test
14 | {
15 |     protected $data = array(
16 |         'default_state' => true,
17 |         'error_code'    => 403,
18 |         'error_message' => 'Interdit',
19 |         'throw_error'   => false,
20 |         'callback'      => 'testMyCallback',
21 |         'entries'       => array(
22 |             '192.168.25.3' => false,
23 |             '127.0.0.1'    => true,
24 |             '10.36.25.*'   => true,
25 |         ),
26 |         'lists'         => array(
27 |             'default'   => false,
28 |             'partners'  => true,
29 |         ),
30 |         'config'        => "default",
31 |         'actions'       => array(
32 |             'indexAction',
33 |             'testAction',
34 |         ),
35 |     );
36 | 
37 |     public function testConstructor()
38 |     {
39 |         $annotation = new FirewallAnnotation($this->data);
40 | 
41 |         foreach ($this->data as $name => $data) {
42 |             switch ($name) {
43 |                 case 'config':
44 |                 case 'actions':
45 |                     $this->assert
46 |                         ->variable($this->data[$name])
47 |                             ->isIdenticalTo($annotation->$name)
48 |                     ;
49 |                     break;
50 | 
51 |                 default:
52 |                     $this->assert
53 |                         ->variable($this->data[$name])
54 |                             ->isIdenticalTo($annotation->options[$name])
55 |                     ;
56 |                     break;
57 |             }
58 |         }
59 |     }
60 | 
61 |     public function testConstructorWithoutData()
62 |     {
63 |         $annotation = new FirewallAnnotation(array());
64 | 
65 |         $this->assert
66 |             ->variable($annotation->config)
67 |                 ->isNull()
68 |             ->variable($annotation->actions)
69 |                 ->isNull()
70 |         ;
71 | 
72 |         foreach ($annotation->options as $name => $value) {
73 |             switch ($name) {
74 |                 case 'entries':
75 |                 case 'lists':
76 |                     $this->assert
77 |                         ->array($value)
78 |                             ->isEmpty()
79 |                     ;
80 |                     break;
81 | 
82 |                 default:
83 |                     $this->assert
84 |                         ->variable($value)
85 |                             ->isNull()
86 |                     ;
87 |                     break;
88 |             }
89 |         }
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/Tests/Units/Controller/Listener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace M6Web\Bundle\FirewallBundle\Tests\Units\Controller;
 3 | 
 4 | require_once __DIR__.'/../../bootstrap.php';
 5 | 
 6 | use atoum\AtoumBundle\Test\Units;
 7 | 
 8 | use M6Web\Bundle\FirewallBundle\Controller,
 9 |     M6Web\Bundle\FirewallBundle\Firewall\Provider;
10 | 
11 | /**
12 |  * Controller listener test
13 |  */
14 | class Listener extends Units\Test
15 | {
16 |     /**
17 |      * Instantiation test
18 |      *
19 |      * @return Request
20 |      */
21 |     public function testConstruct()
22 |     {
23 |         $this->mockClass('Symfony\Component\DependencyInjection\ContainerInterface', '\Mock');
24 |         $this->mockClass('Symfony\Component\HttpFoundation\Request', '\Mock');
25 |         $this->mockClass('Doctrine\Common\Annotations\AnnotationReader', '\Mock');
26 | 
27 |         $request   = new \Mock\Request();
28 |         $container = new \Mock\ContainerInterface();
29 | 
30 |         $container->getMockController()->get = function($serviceName) use ($request) {
31 |             switch ($serviceName) {
32 |                 case 'request':
33 |                     return $request;
34 |             }
35 |         };
36 | 
37 |         $provider = new Provider($container, array(), array());
38 |         $reader   = new \Mock\AnnotationReader();
39 | 
40 |         $listener = new Controller\Listener($reader, $provider);
41 | 
42 |         $this->assert
43 |             ->object($provider)
44 |                 ->isIdenticalTo($listener->getProvider())
45 |         ;
46 | 
47 |         $this->assert
48 |             ->object($reader)
49 |                 ->isIdenticalTo($listener->getReader())
50 |         ;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Tests/Units/DependencyInjection/M6WebFirewallExtension.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace M6Web\Bundle\FirewallBundle\Tests\Units\DependencyInjection;
  3 | 
  4 | require_once __DIR__.'/../../bootstrap.php';
  5 | 
  6 | use atoum\AtoumBundle\Test\Units;
  7 | 
  8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
  9 | 
 10 | use M6Web\Bundle\FirewallBundle\DependencyInjection\M6WebFirewallExtension as FirewallExt;
 11 | 
 12 | /**
 13 |  * Test of the FirewallBundle extension declaration
 14 |  */
 15 | class M6WebFirewallExtension extends Units\Test
 16 | {
 17 |     protected $configs = array(
 18 |         array(
 19 |            'configs' => array(
 20 |                 'default' => array(
 21 |                     'default_state' => true,
 22 |                     'error_code'    => 400,
 23 |                     'error_message' => 'Interdit',
 24 |                     'throw_error'   => false,
 25 |                 ),
 26 |             ),
 27 |             'lists' => array(
 28 |                 'partners' => array(
 29 |                     '10.20.30.40',
 30 |                     '40.30.20.10',
 31 |                 ),
 32 |             ),
 33 |         ),
 34 |         array(
 35 |             'configs' => array(
 36 |                 'default' => array(
 37 |                     'lists'   => array(
 38 |                         'default'  => true,
 39 |                         'partners' => false,
 40 |                     ),
 41 |                     'entries' => array(
 42 |                         '127.0.0.1'   => true,
 43 |                         '192.168.1.1' => false,
 44 |                     ),
 45 |                 ),
 46 |             ),
 47 |             'lists' => array(
 48 |                 'default' => array(
 49 |                     'ipv6' => array('::1'),
 50 |                     'ipv4' => array(
 51 |                         '192.168.1.*',
 52 |                         '192.168.0.0-192.168.0.254',
 53 |                     ),
 54 |                 ),
 55 |             ),
 56 |         )
 57 |     );
 58 | 
 59 |     /**
 60 |      * Configuration load test
 61 |      */
 62 |     public function testLoad()
 63 |     {
 64 |         $container = new ContainerBuilder();
 65 | 
 66 |         $loader = new FirewallExt();
 67 |         $loader->load($this->configs, $container);
 68 | 
 69 |         $this->assert
 70 |             ->string($container->getParameter('m6web.firewall.class'))
 71 |                 ->isEqualTo('M6Web\Bundle\FirewallBundle\Firewall\Firewall')
 72 |             ->array($container->getParameter('m6web.firewall.lists'))
 73 |                 ->isEqualTo(array(
 74 |                     'default' => array(
 75 |                         '::1',
 76 |                         '192.168.1.*',
 77 |                         '192.168.0.0-192.168.0.254',
 78 |                     ),
 79 |                     'partners' => array(
 80 |                         '10.20.30.40',
 81 |                         '40.30.20.10',
 82 |                     ),
 83 |                 ))
 84 |             ->array($container->getParameter('m6web.firewall.configs'))
 85 |                 ->isEqualTo(array(
 86 |                     'default' => array(
 87 |                         'default_state' => true,
 88 |                         'error_code'    => 400,
 89 |                         'error_message' => 'Interdit',
 90 |                         'throw_error'   => false,
 91 |                         'lists'   => array(
 92 |                             'default'  => true,
 93 |                             'partners' => false,
 94 |                         ),
 95 |                         'entries' => array(
 96 |                             '127.0.0.1'   => true,
 97 |                             '192.168.1.1' => false,
 98 |                         ),
 99 |                     ),
100 |                 ))
101 | 
102 |             ->object($providerDefinition = $container->getDefinition('m6web.firewall.provider'))
103 |             ->string($providerDefinition->getClass())
104 |                 ->isEqualTo('M6Web\Bundle\FirewallBundle\Firewall\Provider')
105 |             ->object($providerDefinition->getArgument(0))
106 |                 ->isInstanceOf('Symfony\Component\DependencyInjection\Reference')
107 |             ->string((string) $providerDefinition->getArgument(0))
108 |                 ->isEqualTo('service_container')
109 |             ->string($providerDefinition->getArgument(1))
110 |                 ->isEqualTo('%m6web.firewall.lists%')
111 |             ->string($providerDefinition->getArgument(2))
112 |                 ->isEqualTo('%m6web.firewall.configs%')
113 |             ->array($providerDefinition->getMethodCalls())
114 |                 ->hasSize(1)
115 |             ->array($providerDefinition->getMethodCalls()[0])
116 |                 ->isEqualTo(array('setFirewallClass', array('%m6web.firewall.class%')))
117 | 
118 |             ->object($listenerDefinition = $container->getDefinition('m6web.firewall.controller_listener'))
119 |             ->string($listenerDefinition->getClass())
120 |                 ->isEqualTo('M6Web\Bundle\FirewallBundle\Controller\Listener')
121 |             ->object($listenerDefinition->getArgument(0))
122 |                 ->isInstanceOf('Symfony\Component\DependencyInjection\Reference')
123 |             ->string((string) $listenerDefinition->getArgument(0))
124 |                 ->isEqualTo('annotation_reader')
125 |             ->object($listenerDefinition->getArgument(1))
126 |                 ->isInstanceOf('Symfony\Component\DependencyInjection\Reference')
127 |             ->string((string) $listenerDefinition->getArgument(1))
128 |                 ->isEqualTo('m6web.firewall.provider')
129 |             ->array($listenerDefinition->getTag('kernel.event_listener'))
130 |                 ->isEqualTo(array(array('event' => 'kernel.controller', 'method' => 'onCoreController', 'priority' => -255)))
131 |             ;
132 |     }
133 | }
134 | 


--------------------------------------------------------------------------------
/Tests/Units/EventListener/RequestListener.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace M6Web\Bundle\FirewallBundle\Tests\Units\EventListener;
  3 | 
  4 | require_once __DIR__.'/../../bootstrap.php';
  5 | 
  6 | use atoum\AtoumBundle\Test\Units;
  7 | 
  8 | use M6Web\Bundle\FirewallBundle\EventListener\RequestListener as TestedClass;
  9 | use Symfony\Component\HttpFoundation\RequestMatcher;
 10 | use Symfony\Component\HttpKernel\HttpKernelInterface;
 11 | 
 12 | /**
 13 |  * Request listener test
 14 |  */
 15 | class RequestListener extends Units\Test
 16 | {
 17 |     /**
 18 |      * test on request with a request matching pattern
 19 |      *
 20 |      * @return Request
 21 |      */
 22 |     public function testOnRequestWithValidRequest()
 23 |     {
 24 |         $request            = \Symfony\Component\HttpFoundation\Request::create('/test');
 25 |         $mockKernel         = new \mock\Symfony\Component\HttpKernel\HttpKernelInterface();
 26 |         $event              = new \Symfony\Component\HttpKernel\Event\GetResponseEvent($mockKernel, $request, HttpKernelInterface::MASTER_REQUEST);
 27 |         $mockedProvider     = $this->getMockedProvider();
 28 |         $requestListener    = new TestedClass($mockedProvider);
 29 | 
 30 |         $this->if($requestListener)
 31 |             ->then($requestListener->onRequest($event))
 32 |             ->mock($mockedProvider)
 33 |                 ->call('getPatterns')
 34 |                     ->once()
 35 |                 ->call('getFirewall')
 36 |                     ->withArguments('configTest')
 37 |                     ->once();
 38 |     }
 39 | 
 40 |     /**
 41 |      * test on request with a request not matching pattern
 42 |      *
 43 |      * @return Request
 44 |      */
 45 |     public function testOnRequestWithUnValidRequest()
 46 |     {
 47 |         $request            = \Symfony\Component\HttpFoundation\Request::create('/toto');
 48 |         $mockKernel         = new \mock\Symfony\Component\HttpKernel\HttpKernelInterface();
 49 |         $event              = new \Symfony\Component\HttpKernel\Event\GetResponseEvent($mockKernel, $request, HttpKernelInterface::MASTER_REQUEST);
 50 |         $mockedProvider     = $this->getMockedProvider();
 51 |         $requestListener    = new TestedClass($mockedProvider);
 52 | 
 53 |         $this->if($requestListener)
 54 |             ->then($requestListener->onRequest($event))
 55 |             ->mock($mockedProvider)
 56 |                 ->call('getPatterns')
 57 |                     ->once()
 58 |                 ->call('getFirewall')
 59 |                     ->never();
 60 |     }
 61 | 
 62 |     /**
 63 |      * test on request with a request not matching pattern
 64 |      *
 65 |      * @return Request
 66 |      */
 67 |     public function testOnRequestWithSubRequest()
 68 |     {
 69 |         $request            = \Symfony\Component\HttpFoundation\Request::create('/test');
 70 |         $mockKernel         = new \mock\Symfony\Component\HttpKernel\HttpKernelInterface();
 71 |         $event              = new \Symfony\Component\HttpKernel\Event\GetResponseEvent($mockKernel, $request, HttpKernelInterface::SUB_REQUEST);
 72 |         $mockedProvider     = $this->getMockedProvider();
 73 |         $requestListener    = new TestedClass($mockedProvider);
 74 | 
 75 |         $this->if($requestListener)
 76 |             ->then($requestListener->onRequest($event))
 77 |             ->mock($mockedProvider)
 78 |                 ->call('getFirewall')
 79 |                     ->never();
 80 |     }
 81 | 
 82 |     /**
 83 |      * test on request with no patterns
 84 |      *
 85 |      * @return Request
 86 |      */
 87 |     public function testOnRequestWithNoPatterns()
 88 |     {
 89 |         $request        = \Symfony\Component\HttpFoundation\Request::create('/toto');
 90 |         $mockKernel     = new \mock\Symfony\Component\HttpKernel\HttpKernelInterface();
 91 |         $event          = new \Symfony\Component\HttpKernel\Event\GetResponseEvent($mockKernel, $request, HttpKernelInterface::MASTER_REQUEST);
 92 |         $mockedProvider = $this->getMockedProvider();
 93 |         $mockedProvider->getMockController()->getPatterns = function() {
 94 |             return null;
 95 |         };
 96 |         $requestListener = new TestedClass($mockedProvider);
 97 | 
 98 |         $this->if($requestListener)
 99 |             ->then($requestListener->onRequest($event))
100 |             ->mock($mockedProvider)
101 |                 ->call('getPatterns')
102 |                     ->once()
103 |                 ->call('getFirewall')
104 |                     ->never();
105 |     }
106 | 
107 |     protected function getMockedProvider()
108 |     {
109 |         $firewallProvider = new \mock\M6Web\Bundle\FirewallBundle\Firewall\ProviderInterface();
110 | 
111 |         $firewallProvider->getMockController()->getPatterns = function() {
112 |             return array(
113 |                 'pattern1' => array(
114 |                     'path' => '/test',
115 |                     'config' => 'configTest',
116 |                     'matcher' => new RequestMatcher('/test')
117 |                 )
118 |             );
119 |         };
120 | 
121 |         $firewallProvider->getMockController()->getFirewall = function() {
122 |             return new \mock\M6Web\Bundle\FirewallBundle\Firewall\FirewallInterface();
123 |         };
124 | 
125 |         return $firewallProvider;
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/Tests/Units/Firewall/Provider.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace M6Web\Bundle\FirewallBundle\Tests\Units\Firewall;
  3 | 
  4 | require_once __DIR__.'/../../bootstrap.php';
  5 | 
  6 | use atoum\AtoumBundle\Test\Units;
  7 | 
  8 | use M6Web\Bundle\FirewallBundle\Firewall;
  9 | use Symfony\Component\HttpFoundation\RequestMatcher;
 10 | 
 11 | /**
 12 |  * Firewall manager test
 13 |  */
 14 | class Provider extends Units\Test
 15 | {
 16 |     protected $request;
 17 | 
 18 |     protected $configs = array(
 19 |         'default' => array(
 20 |             'default_state' => true,
 21 |             'error_code'    => 400,
 22 |             'error_message' => 'Interdit',
 23 |             'throw_error'   => false,
 24 |             'lists'   => array(
 25 |                 'default'  => true,
 26 |                 'partners' => false,
 27 |             ),
 28 |             'entries' => array(
 29 |                 '127.0.0.1'   => true,
 30 |                 '192.168.1.1' => false,
 31 |             ),
 32 |         ),
 33 |         'empty' => array(
 34 |             'toomuch' => true,
 35 |         ),
 36 |     );
 37 | 
 38 |     protected $patterns = array(
 39 |         'pattern1' => array(
 40 |             'config' => 'default',
 41 |             'path' => '/test'
 42 |         )
 43 |     );
 44 | 
 45 |     protected $expectedConfig = array(
 46 |         'default' => array(
 47 |             'default_state' => true,
 48 |             'error_code'    => 400,
 49 |             'error_message' => 'Interdit',
 50 |             'throw_error'   => false,
 51 |             'lists'   => array(
 52 |                 'default'  => true,
 53 |                 'partners' => false,
 54 |             ),
 55 |             'entries' => array(
 56 |                 '127.0.0.1'   => true,
 57 |                 '192.168.1.1' => false,
 58 |             ),
 59 |         ),
 60 |         'empty' => array(
 61 |             'default_state' => null,
 62 |             'error_message' => null,
 63 |             'error_code' => null,
 64 |             'throw_error' => null,
 65 |             'lists' => null,
 66 |             'entries' => array(),
 67 |         ),
 68 |     );
 69 | 
 70 |     protected $lists = array(
 71 |         'default' => array(
 72 |             '::1',
 73 |             '192.168.1.*',
 74 |             '192.168.0.0-192.168.0.254',
 75 |         ),
 76 |         'partners' => array(
 77 |             '10.20.30.40',
 78 |             '40.30.20.10',
 79 |         ),
 80 |     );
 81 | 
 82 |     /**
 83 |      * Instantiation test
 84 |      */
 85 |     public function testConstruct()
 86 |     {
 87 |         $provider = $this->getProvider();
 88 | 
 89 |         $this->assert
 90 |             ->array($provider->getLists())
 91 |                 ->isEqualTo($this->lists)
 92 |             ->array($provider->getConfigs())
 93 |                 ->isEqualTo($this->expectedConfig)
 94 |             ->array($provider->getPatterns())
 95 |                 ->isEqualTo($this->getExpectedPatterns());
 96 |     }
 97 | 
 98 |     /**
 99 |      * Generation test
100 |      */
101 |     public function testGetFirewall()
102 |     {
103 |         $provider = $this->getProvider();
104 |         $provider->setFirewallClass('\mock\M6Web\Bundle\FirewallBundle\Firewall\FirewallInterface');
105 |         $controller = new \atoum\mock\controller();
106 |         $addListCalls = array();
107 |         $controller->addList = function () use (&$addListCalls) {
108 |             $addListCalls[] = func_get_args();
109 |         };
110 | 
111 |         $firewall = $provider->getFirewall('default', array(
112 |             'default_state' => false,
113 |             'error_message' => 'TestOptions',
114 |         ));
115 | 
116 |         $this
117 |             ->mock($firewall)
118 |                 ->call('setProvider')
119 |                     ->withIdenticalArguments($provider)
120 |                     ->once()
121 |                 ->call('setRequest')
122 |                     ->withIdenticalArguments($this->request)
123 |                     ->once()
124 |                 ->call('setDefaultState')
125 |                     ->withIdenticalArguments(false)
126 |                     ->once()
127 |                 ->call('setErrorMessage')
128 |                     ->withIdenticalArguments('TestOptions')
129 |                     ->once()
130 |                 ->call('setErrorCode')
131 |                     ->withIdenticalArguments(400)
132 |                     ->once()
133 |                 ->call('setThrowError')
134 |                     ->withIdenticalArguments(false)
135 |                     ->once();
136 | 
137 |         $this->assert
138 |             ->array($addListCalls)
139 |                 ->hasSize(4)
140 |             ->array($addListCalls[0])
141 |                 ->isEqualTo(array(array(
142 |                     '::1',
143 |                     '192.168.1.*',
144 |                     '192.168.0.0-192.168.0.254',
145 |                 ), 'default', true))
146 |             ->array($addListCalls[1])
147 |                 ->isEqualTo(array(array(
148 |                     '10.20.30.40',
149 |                     '40.30.20.10',
150 |                 ), 'partners', false))
151 |             ->array($addListCalls[2])
152 |                 ->isEqualTo(array(array(
153 |                     '192.168.1.1',
154 |                 ), 'blackedOptions', false))
155 |             ->array($addListCalls[3])
156 |                 ->isEqualTo(array(array(
157 |                     '127.0.0.1',
158 |                 ), 'whitedOptions', true));
159 |     }
160 | 
161 |     protected function getExpectedPatterns()
162 |     {
163 |         return array(
164 |             'pattern1' => array(
165 |                 'config' => 'default',
166 |                 'path' => '/test',
167 |                 'matcher' => new RequestMatcher('/test')
168 |             )
169 |         );
170 |     }
171 | 
172 |     /**
173 |      * Get a provider mock
174 |      *
175 |      * @return Firewall\Provider
176 |      */
177 |     protected function getProvider()
178 |     {
179 |         $container = new \Mock\Symfony\Component\DependencyInjection\ContainerInterface();
180 |         $request = new \Mock\Symfony\Component\HttpFoundation\Request();
181 |         $this->request = $request;
182 |         $container->getMockController()->has = function ($serviceName) {
183 |             switch ($serviceName) {
184 |                 case 'request_stack':
185 |                     return true;
186 |                 case 'request':
187 |                     return false;
188 |             }
189 |         };
190 |         $container->getMockController()->get = function ($serviceName) use ($request) {
191 |             switch ($serviceName) {
192 |                 case 'request_stack':
193 |                     $requestStack = new \Symfony\Component\HttpFoundation\RequestStack();
194 |                     $requestStack->push($request);
195 | 
196 |                     return $requestStack;
197 |             }
198 |         };
199 | 
200 |         return new Firewall\Provider($container, $this->lists, $this->configs, $this->patterns);
201 |     }
202 | }
203 | 


--------------------------------------------------------------------------------
/Tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require_once __DIR__.'/../vendor/atoum/atoum/scripts/runner.php';
4 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "m6web/firewall-bundle",
 3 |     "type": "symfony-bundle",
 4 |     "description" : "Bundle providing IP filtering features for controllers and actions",
 5 |     "keywords": ["firewall","IP","filtering","symfony","bundle"],
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "M6Web",
10 |             "email": "opensource@m6web.fr",
11 |             "homepage": "http://tech.m6web.fr/"
12 |         }
13 |     ],
14 |     "autoload": {
15 |         "psr-0": {"M6Web\\Bundle\\FirewallBundle": ""}
16 |     },
17 |     "target-dir": "M6Web/Bundle/FirewallBundle",
18 |     "require": {
19 |         "php": ">=7.0.0",
20 |         "ext-bcmath": "*",
21 |         "m6web/firewall": "~1.0"
22 |     },
23 |     "require-dev": {
24 |         "atoum/atoum": "^2.8|^3.0",
25 |         "atoum/atoum-bundle": "@stable",
26 |         "symfony/symfony": "^2.2|^3.0|^4.0"
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------