src/Security/Authorization/Voter/ClientIpVoter.php line 16

Open in your IDE?
  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Ninon
  5.  * Date: 22/03/2017
  6.  * Time: 15:16
  7.  */
  9. namespace App\Security\Authorization\Voter;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  14. use Symfony\Component\Security\Core\Authorization\Voter\Voter;
  16. class ClientIpVoter extends Voter
  17. {
  18.     const ALLOW = 'allow';
  19.     const DENY = 'deny';
  21.     /**
  22.      * @var array
  23.      */
  24.     protected $_sListeIPs;
  26.     /**
  27.      * ClientIpVoter constructor.
  28.      *
  29.      * @param array $aListeIPs
  30.      */
  31.     public function __construct(array $aListeIPs)
  32.     {
  33.         $this->_sListeIPs = $aListeIPs;
  34.     }
  36.     /**
  37.      * Determines if the attribute and subject are supported by this voter.
  38.      *
  39.      * @param string $attribute An attribute
  40.      * @param mixed $subject The subject to secure, e.g. an object the user wants to access or any other PHP type
  41.      *
  42.      * @return bool True if the attribute and subject are supported, false otherwise
  43.      */
  44.     protected function supports(string $attribute, $subject)
  45.     {
  46.         // if the attribute isn't one we support, return false
  47.         if (!in_array($attribute, [self::ALLOW, self::DENY])) {
  48.             return false;
  49.         }
  51.         // only vote on `Request` objects
  52.         if (!$subject instanceof Request) {
  53.             return false;
  54.         }
  56.         return true;
  57.     }
  60.     /**
  61.      * Perform a single access check operation on a given attribute, subject and token.
  62.      * It is safe to assume that $attribute and $subject already passed the "supports()" method check.
  63.      *
  64.      * @param mixed $subject
  65.      *
  66.      * @return bool
  67.      */
  68.     protected function voteOnAttribute(string $attribute, $subject, TokenInterface $token)
  69.     {
  70.         // you know $subject is a Post object, thanks to `supports()`
  71.         /** @var Request $request */
  72.         $request = $subject;
  73.         $route = $request->get('_route');
  74.         if ($route === 'admin_noutonline_version'){
  75.             switch ($attribute)
  76.             {
  77.                 case self::ALLOW:
  78.                     return true;
  79.                 case self::DENY:
  80.                     return false;
  81.             }
  82.         }
  83.         $sClientIP = $request->getClientIp();
  85.         $bMatche = false;
  86.         foreach($this->_sListeIPs as $range)
  87.         {
  88.             if ($this->_bTestIP($sClientIP, $range)){
  89.                 $bMatche = true;
  90.                 break;
  91.             }
  92.         }
  94.         switch ($attribute)
  95.         {
  96.             case self::ALLOW:
  97.                 return $bMatche;
  98.             case self::DENY:
  99.                 return !$bMatche;
  100.         }
  102.         return false;
  103.     }
  105.     /**
  106.      * transforme une ip en chaine binaire
  107.      * @param $sIP
  108.      * @return string
  109.      */
  110.     protected function _sIP2bits($sIP)
  111.     {
  112.         $cx = strpos($sIP, '/');
  113.         if (!$cx)
  114.         {
  115.             $in_addr = inet_pton($sIP);
  116.             return bin2hex($in_addr);
  117.         }
  119.         // Strip out the netmask, if there is one.
  120.         $subnet = (int)(substr($sIP, $cx+1));
  121.         $ipaddr = substr($sIP, 0, $cx);
  123.         $in_addr = inet_pton($ipaddr);
  124.         $aByteAddr = str_split($in_addr);
  126.         // Maximum netmask length = same as packed address
  127.         $len = 8*strlen($in_addr);
  128.         if ($subnet > $len){
  129.             $subnet = $len;
  130.         }
  132.         // Create a hex expression of the subnet mask
  133.         $mask  = str_repeat('f', $subnet>>2);
  134.         switch($subnet & 3)
  135.         {
  136.         case 3: $mask .= 'e'; break;
  137.         case 2: $mask .= 'c'; break;
  138.         case 1: $mask .= '8'; break;
  139.         }
  140.         $mask = str_pad($mask, $len>>2, '0');
  142.         // Packed representation of netmask
  143.         $mask = pack('H*', $mask);
  144.         $aByteMask = str_split($mask);
  146.         $sIpRes = '';
  147.         for ($i=0 ; $i<count($aByteAddr) ; $i++)
  148.         {
  149.             $nValIp = ord($aByteAddr[$i]);
  150.             $nValMasque = isset($aByteMask[$i]) ? ord($aByteMask[$i]) : 0;
  152.             $sIpRes.= str_pad(dechex($nValIp & $nValMasque), 2, '0', STR_PAD_LEFT);
  153.         }
  155.         return $sIpRes;
  156.     }
  158.     /**
  159.      * Compare l'ip du client avec le range
  160.      * @param $clientIP
  161.      * @param $range
  162.      * @return bool
  163.      */
  164.     protected function _bTestIP($clientIP, $range)
  165.     {
  166.         $cx = strpos($range, '/');
  167.         if ($cx){
  168.             $clientIP .= substr($range, $cx);
  169.         }
  171.         $sBinClientIp = $this->_sIP2bits($clientIP);
  172.         $sBinRange = $this->_sIP2bits($range);
  174.         return strcasecmp($sBinClientIp, $sBinRange)==0;
  175.     }
  178. }