1. 홈
  2. 질의 응답
  3. IP 주소를 사용하여 사이트에 대한 액세스 제한

IP 주소를 사용하여 사이트에 대한 액세스 제한

2009-09-08 12 views
2

사이트의 사용자가 특정 범위의 IP 주소 범위 내에있는 경우에만 사이트의 내부 페이지에만 액세스 할 수 있도록 제한하는 방법이 있는지 알고 싶습니다 또는 특정 네트워크?IP 주소를 사용하여 사이트에 대한 액세스 제한

현재 PHP 스크립트는 프록시에서 실제 IP를 구별 할 수 없습니까?

감사합니다.

출처

2009-09-08 Stanley Ngumo

답변

4

나는 IP 주소를 제한하지 않습니다. 당신이 말했듯이, 그것이 프록시인지 알 수 없습니다. 또한 IP 주소를 쉽게 스푸핑 할 수 있습니다.

출처

2009-09-08 07:15:04 knittl

+1

감사합니다, 당신은 위치를 기반으로 사이트에 항목을 제한하는 방법에 대한 제안을 할 것이다? –

+0

아니요, 두렵습니다. 당신은 IP 주소를 사용해야 할 것이다. 그러나 내가 알고있는 "프록시 차단"방법이 없다. – knittl

+0

암호로 .htaccess 파일을 사용하는 것 외에도 IP 주소를 확인하는 것으로 충분하다. http://www.htaccesstools.com/htpasswd-generator/ – jimiyash

0

프록시 서버는 $_SERVER['HTTP_X_FORWARDED_FOR']으로 확인할 수있는 X-Forwarded-For HTTP 헤더를 설정해야합니다. 그렇지 않으면 $_SERVER['REMOTE_ADDR']을 사용하여 IP 주소를 가져올 수 있습니다. 다른 사람들이 지적했듯이이 두 가지 모두 쉽게 스푸핑 될 수 있으며 프록시는 요청 헤더를 X-Forwarded-For으로 설정할 필요가 없습니다.

범위 검사에 사용할 정수를 제공하는 PHP에 ip2long() 함수가 있습니다.

IP 주소의 위치를 ​​얻으려면 IP 주소 범위를 대략적인 지리적 위치 (룩업 테이블은 일반적으로 무료가 아닙니다)로 매핑하는 조회 테이블이 필요합니다. IP 주소 geolocation을 제공하는 많은 서비스가 있으며 그 중 일부는 here 및 here입니다.

출처

2009-09-08 08:01:41

2

매우 고급 IP 규칙을 허용하도록 만든 스크립트를 사용해 볼 수 있습니다. 나는 몇 년 전에 그것을 코딩 했으므로 나는 그것의 현재 모양을 미리 사과한다.

편집 : 구문에서 "&"연산자를 찾으려면 신경 쓰지 마세요. 나는 이것을 코딩 할 때 그것을 추가하는 것을 잊어 버렸고이 스크립트를 되돌아 보니 이제는 다시 만지는 것을 생각하면 나를 싫어하게 만듭니다.

<?php 
############################################################## 
# IP Expression Class          # 
# Easy IP-based Access Restrictions       # 
# Change Log:            # 
# - Added Range and limited IPv6 support      # 
# - Changed name from IPAR to IPEX       # 
#        # 
############################################################## 
# Example Rules:            # 
# 69.[10-20].[^50].*           # 
# 69.*.[1-5 | 10-20 |^30].*         # 
# 60.12.2.*             # 
# 127.*              # 
# 69.1.1.1-70.1.1.1 <-- This is a range     # 
#               # 
# Usage:              # 
# Ipex::IsMatch($rule, $ip);         # 
#               # 
# [range] - Defines a range for a section of the IP   # 
# | - OR token. IP can match this range/number   # 
#^  - NOT token. IP can not match this range/number # 
# x-y  - Defines a range from x to y      # 
# x  - Exactly match x (x = a hex or dec number)  # 
# *  - Match any number         # 
#        # 
#----------===============================-------------------# 
#   [ Written by Chris Tarquini ]     # 
#----------===============================-------------------# 
############################################################## 

define('IPR_DENY', false); 
define('IPR_ALLOW', true); 
define('IPR_ERR_MISMATCH',-1); 
define('IPR_ERR_RANGE_MISMATCH',-2); 
define('IPR_ERR_RANGE_INVALID',-3); 
define('IPR_ERR_INVALID_RULE',-4); 

class IPEX 
{ 

    const TOKEN_RANGE_BEGIN = '['; 
    const TOKEN_RANGE_END = ']'; 
    const TOKEN_WILDCARD = '*'; 
    const TOKEN_RANGE_SPLIT = '-'; 
    const TOKEN_OR = '|'; 
    const TOKEN_NOT = '^'; 
    const DEBUG_MODE = TRUE; 

    private static function trace($err){if(self::DEBUG_MODE) echo "$err\r\n";} 
    private static function FixRule($rule,$count = 4, $split='.') 
    { 
     $rule = explode($split,$rule); 
     $filler = 0; 
     $size = sizeof($rule); 
     for($i = 0; $i < $count; $i++) 
     { 
      if($i > $size) { $rule[] = $filler; $size++;} 
      else if(empty($rule[$i])) { $filler = self::TOKEN_WILDCARD; $rule[$i] = $filler;} 
     } 
     return $rule; 
    } 

    private static function FixIP($rule,$count = 4, $split='.') 
    { 
     $rule = explode($split,$rule); 
     $size = sizeof($rule); 
     for($i = 0; $i < $count; $i++) 
     { 
      if($i > $size) { $rule[] = 0; $size++;} 
      else if(empty($rule[$i])) { $rule[$i] = 0;} 
     } 
     return $rule; 
    } 
    private static function GetIpType(&$ip) 
    { 
     $mode = IPID::Identify($ip,$newip); 
     if($mode == IPID_IPv4_Embed) { $ip = $newip; return IPID_IPv4;} 
     return $mode; 
    } 
    private static function FixIPRange(&$start, &$stop) 
    { 
     $count = 4; $split = '.'; 
     if(self::GetIpType($start) == IPID_IPv6) {$count = 8; $split = ':';} 

     $q = 0; 
     while($q < 2) 
     { 
      $filler = ($q == 0) ? 0 : 255; 
      $arr = explode($split,($q == 0) ? $start : $stop); 
      $size = sizeof($arr); 
      for($i = 0; $i < $count; $i++) 
      { 
       if($i > $size){ $arr[] = $filler; $size++;} 
       else if(empty($arr[$i])){ $arr[$i] = $filler; } 
      } 
      if($q == 0) $start = implode($split, $arr); 
      else $stop = implode($split,$arr); 
      $q++; 
     } 

    } 
    public static function IsInRange($start, $stop, $ip) 
    { 
     //Sorry guys we only support IPv4 for this ;(
     self::FixIPRange($start,$stop); 
     self::trace("fixed: start = $start, stop = $stop"); 
     $start = ip2long($start); $stop = ip2long($stop); 
     $ip = ip2long($ip); 
     self::trace("start = $start, stop = $stop, ip = $ip"); 
     return ($ip >= $start && $ip <= $stop); 
    } 
    public static function IsAllowed($rule, $ip){return self::IsMatch($rule,$ip);} 
    public static function IsMatch($rule,$ip) 
    { 
     $mode = self::GetIpType($ip); 
     self::trace("ip type: $mode"); 
     if(strpos($rule, self::TOKEN_RANGE_SPLIT) !== false && strpos($rule,self::TOKEN_RANGE_BEGIN) === false) 
     { 
      self::trace("ip range mode"); 
      $test = explode(self::TOKEN_RANGE_SPLIT, $rule); 
      self::trace("range size: ".sizeof($test)); 
      print_r($test); 
      if(sizeof($test) != 2) return IPR_ERR_RANGE_INVALID; 
      $start = $test[0]; $end = $test[1]; 
      if(empty($start) || empty($end)) return IPR_ERR_RANGE_INVALID; 
      self::trace("range start: $start, range stop: $end"); 
      $rm1 = (self::IsHex($start)) ? $mode : self::GetIpType($start); 
      $rm2 = (self::IsHex($end)) ? $mode : self::GetIpType($end); 
      self::trace("range types: $rm1, $rm2\r\nip type: $mode"); 
      if($rm1 != $rm2 || $rm1 != $mode) return IPR_ERR_RANGE_MISMATCH; 
      if($mode == IPID_IPv6) { return IPR_ERR_IPv6_NOTSUPPORTED;}  
      return self::IsInRange($start,$end,$ip); 
     } 

     if(self::GetIpType($rule) != $mode) return IPR_ERR_MISMATCH; 


     //all is good so far 
     $count = 4; 
     $split = '.'; if($mode==IPID_IPv6){$count = 8; $split=':';} 
     $rule = self::FixRule($rule, $count,$split); 

     $ip = self::FixIp($ip,$count,$split); 
     self::trace("ip: ".implode($split,$ip)); 
     self::trace('rule: '.implode($split,$rule)); 
     for($i = 0; $i < $count; $i++) 
     { 
      $r = str_replace(' ', '', $rule[$i]); 
      $ri = false; 
if($r == self::TOKEN_WILDCARD) continue; 
      if($mode == IPPID_IPv6 && self::IsHex($r)) { $ri = hexdec($r);}else if(is_numeric($r)) $ri = $r; 


      $x = $ip[$i]; 
      if($mode == IPPID_IPv6) $x = hexdec($x); 
      //* Exact Match *// 
      self::trace("rule[$i]: $ri"); 
      self::trace("ip[$i]: $x"); 
      if($ri !== false && $ri != $x) return IPR_DENY; 
      $len = strlen($r); 
      for($y = 0; $y < $len; $y++) 
      { 
       self::trace("y = $y"); 
       if(substr($r, $y,1) == self::TOKEN_RANGE_BEGIN) 
       { 
        ++$y; 
        self::trace("found range, y = $y"); 
        $negflag = false; 
        $start = false; 
        $stop = false; 
        $allows = 0; 
        $denys = 0; 
        $q = 0; 
        $c = substr($r,$y,1); 
        while($c !== false) 
        { 
         self::trace("in range, char: $c"); 
         //* Flags *// 
         $break = false; 
         $exec = false; 
         $toggle = false; 
         $reset = false; 

         if($c === self::TOKEN_RANGE_END) {$skiphex = true;$break = true; $exec = true; self::trace("found end of range");} 
         if($c === self::TOKEN_NOT) {if($q > 0){ $toggle = true; $exec = true;} else $negflag = !$negflag; $skiphex =false; self::trace("found TOKEN_NOT");} 
         if($c === self::TOKEN_OR) { $exec = true; $reset = true;$skiphex=true;self::trace("found TOKEN_OR");} 
         if($c === self::TOKEN_RANGE_SPLIT){ $skiphex = false;++$q; self::trace("found range split");} 

         //* Read Hex Tokens *// 
         if(!$skiphex && self::IsHexChar($c)) 
         { 
          $n = self::ReadNextHexToken($r,$y); 
          if($mode == IPID_IPv6) $n = hexdec($n); 
          if($q == 0) $start = $n; 
          else if($q == 1) $stop = $n; 
          --$y; //fixes error 
          self::trace("parsed number: $n, y = $y"); 
         } 
         if($reset) {$negflag = false; $start = false; $stop = false; $q = 0;} 
         if($exec) 
         { 
          self::trace("executing: start = $start, stop = $stop, x = $x"); 
          self::trace("negflag = $negflag"); 
          if($stop !== false && $x >= $start && $x <= $stop) 
          { 
           if($negflag) { ++$denys; $allows = 0; break;} 
           else ++$allows; 
          } 
          else if($stop === false && $start == $x) 
          { 
           if($negflag) { ++$denys; $allows = 0; break;} 
           else ++$allows; 
          } 
          self::trace("exec complete: allows = $allows, denys = $denys"); 
          $q = 0; 
         } 
         if($toggle) $negflag = !$negflag; 
         if($break) break; 
         ++$y; 
         $c = substr($r,$y,1); 
        } 
        if(!$allows) return IPR_DENY; 
       } 
      } 


     } 
       return IPR_ALLOW; 

    } 
    private static function ReadNextHexToken($buff, &$offset, $max = -1) 
    { 
     $str = ''; 
     if($max == -1) { $max = strlen($buff);} 
     for(; $offset < $max; $offset++) 
     { 
      $c = substr($buff,$offset, 1); 
      if(self::IsHexChar($c)) 
       $str .= $c; 
      else 
       return $str; 
     } 
     return $str; 
    } 
    private static function IsHex($x){ $len = strlen($x); for($i = 0; $i < $len; $i++) if(!self::IsHexChar(substr($x,$i,1))) return false; return true;} 
    private static function IsHexChar($x){self::trace("isHex($x);"); return (in_array(strtoupper($x),array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'))); 
} 
} 



###################### 
# IP Identify Class # 
##################### 
define('IPID_INVALID',false); 
define('IPID_IPv4',2); 
define('IPID_IPv6',3); 
define('IPID_IPv4_Embed',6); 

class IPID 
{ 

     public static function Identify($ip,&$ipconvert = false) 
     { 
       $ip = strtoupper($ip); 
       $ipconvert = $ip; 
       // Check if we are IPv4 
       if(strpos($ip,':') === false && strpos($ip,'.') !== false) 
         return IPID_IPv4; 
       //Is it one of those fucked up hybrid mother fuckers? 
       else if(strpos($ip,':FFFF') !== false && strpos($ip,'.') !== false) 
       { 
         $ipconvert = substr($ip,strpos($ip,':FFFF:')+6); 
         return IPID_IPv4_Embed; 
       } 
       // Is it IPv6? 
       else if(strpos($ip,':') !== false) return IPID_IPv6; 
       // What the fuck? 
       return IPID_INVALID; 
     } 


} 
?>

재판매하지 않는 한 머리글을 그대로 사용할 수 있습니다. 답변에 대한

출처

2010-01-09 21:35:54

0 
<?php 
    //This function returns True if visitor IP is allowed. 
    //Otherwise it returns False. 
    function CheckAccess() 
    { 
     //allowed IP. Change it to your static IP 
     $allowedip = '127.0.0.1'; 
     $ip = $_SERVER['REMOTE_ADDR']; 
     return ($ip == $allowedip); 
    }

출처

2014-11-06 16:56:31

관련 문제

 관련 문제