Prüfen Sie, ob eine IP-Adresse ist privat

Ich mag, um zu überprüfen, ob eine IP-Adresse in einem privaten Netzwerk. Es funktioniert nicht.

Mein code:

<?php
$ip = $_SERVER['REMOTE_ADDR'];

function _isPrivate($ip) 
{
    $i = explode('.', $ip);

    if ($i[0] == 10) {
        return true;
    } else if ($i[0] == 172 && $i[1] > 15 && $i[1] < 32) {
        return true;
    } else if ($i[0] == 192 && $i[1] == 168) {
        return true;
    }
    return false;
}
?>

Dem anderen:

<?php
$ip = $_SERVER['REMOTE_ADDR'];

function _isPrivate($ip) 
{
    $ip = ip2long($ip);
    $net_a = ip2long('10.255.255.255') >> 24; 
    $net_b = ip2long('172.31.255.255') >> 20; 
    $net_c = ip2long('192.168.255.255') >> 16; 

    return $ip >> 24 === $net_a || $ip >> 20 === $net_b || $ip >> 16 === $net_c; 
}
?>

Jede Hilfe wäre sehr geschätzt, danke!

InformationsquelleAutor der Frage Ruth | 2012-12-11

ip php private

function ip_is_private ($ip) {
    $pri_addrs = array (
                      '10.0.0.0|10.255.255.255', //single class A network
                      '172.16.0.0|172.31.255.255', //16 contiguous class B network
                      '192.168.0.0|192.168.255.255', //256 contiguous class C network
                      '169.254.0.0|169.254.255.255', //Link-local address also refered to as Automatic Private IP Addressing
                      '127.0.0.0|127.255.255.255' //localhost
                     );

    $long_ip = ip2long ($ip);
    if ($long_ip != -1) {

        foreach ($pri_addrs AS $pri_addr) {
            list ($start, $end) = explode('|', $pri_addr);

             //IF IS PRIVATE
             if ($long_ip >= ip2long ($start) && $long_ip <= ip2long ($end)) {
                 return true;
             }
        }
    }

    return false;
}

Sehen http://mebsd.com/coding-snipits/check-private-ip-function-php.html

Vielleicht wollen Sie auch heraus zu überprüfen, über die privaten Adressräume hier

InformationsquelleAutor der Antwort Mark Davidson

56

Ich denke, das sollte das problem lösen.

filter_var verwendet die folgenden Validierungsregeln wird false zurückgeben, wenn die IP-Adresse ist eine private.
```
$user_ip = '127.0.0.1';
filter_var(
    $user_ip, 
    FILTER_VALIDATE_IP, 
    FILTER_FLAG_IPV4 | FILTER_FLAG_NO_PRIV_RANGE |  FILTER_FLAG_NO_RES_RANGE
)
```
Überprüfen Sie die links oben für die php-Dokumentation

InformationsquelleAutor der Antwort Dmitri Pavlutin

...meine 5 Cent:

IMHO die zugrunde liegende Frage ist nur "wie um zu überprüfen, ob eine IP-Adresse gehört zu einem Netzwerk?".

Die Antwort ist einfach Binär: IP-Adresse UND network_mask GLEICH network_address.

Spielt zum Beispiel IP-Adresse 10.1.2.3 gehört zum Netzwerk 10.0.0.0 mit der Netzmaske 255.0.0.0? 10.1.2.3 & 255.0.0.0 10.0.0.0 ist, die Antwort ist also: ja, es funktioniert.

Leichter zu sehen, es in Binär:

  00001010 00000001 00000010 00000011 ( 10.1.2.3) ip address
& 11111111 00000000 00000000 00000000 (255.0.0.0) network mask
= 00001010 00000000 00000000 00000000 ( 10.0.0.0) network address

Nur auf die überprüfen müssen, dass für die netwoks, die Sie benötigen (inklusive oder nicht loopback link-local, etc. ):

function _isPrivate($long_ip) {
    return ( ($long_ip & 0xFF000000) === 0x0A000000 ) || //Private A network: 00001010 ....
           ( ($long_ip & 0xFFF00000) === 0xAC100000 ) || //Private B network: 10101100 0001....
           ( ($long_ip & 0xFFFF0000) === 0xC0A80000 ) || //Private C network: 11000000 10101000 ....
           //Link-local and loopback are NOT private range, so the function in the question yield right results to "is in private range?". Seems it was not the desired behaviour... Those cases can also be checked:
           ( ($long_ip & 0xFFFF0000) === 0xA9FE0000 ) || //Link-local       : 10101001 11111110 ....
           ( ($long_ip & 0xFFFF0000) === 0x7F000000 ) || //Loopback         : 01111111 ....
         //...and add all the fancy networks that you want...
           ( ($long_ip & 0xFFFFFF00) === 0xC0AF3000 ) || //Direct Delegation AS112 Service 192.175.48.0/24...
           ( ($long_ip & 0xF0000000) === 0xF0000000 ); //Reserved 240.0.0.0/4
}

Interessant ist die negation der zurückgegebene Wert. Der zurückgegebene Wert nicht wirklich bedeutet, dass die angegebene IP in einem privaten Netzwerk, aber es ist negation nicht wirklich bedeutet, dass die angegebene IP ist eine "öffentliche IP-Adresse" (eine gebräuchliche/normale IP-Adresse) als die Lösung von user4880112 deutlich macht.

IPv6

Das gleiche funktioniert auch für IPv6. Die "private network" - Adressen (formal "Unique-Local", RFC 4193 ) "fc00::/7". So, IP-Adresse & 0xFE00.. === 0xFC00.. ist "privates Netzwerk"

Annahme der erwähnten Antwort und einschließlich up-to-date Informationen von der IANA...

http://www.iana.org/assignments/iana-ipv6-special-registry/iana-ipv6-special-registry.xhtml
http://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml

...wir können ein bisschen mehr Allgemeine Funktion wie diese:

function isPublicAddress($ip) {
  //returns false on failure.
  //negative if it's a private or special address (-4:IPv4, -16:IPv6)
  //positive if it's a common IP public address (4:IPv4, 16:IPv6)

  $networks = array(
    '4' => array('0.0.0.0/8',
      '10.0.0.0/8',
      '100.64.0.0/10',
      '127.0.0.0/8',
      '169.254.0.0/16',
      '172.16.0.0/12',
      '192.0.0.0/24',
      '192.0.0.0/29',
      '192.0.0.8/32',
      '192.0.0.9/32',
      '192.0.0.170/32',
      '192.0.0.170/32',
      '192.0.2.0/24',
      '192.31.196.0/24',
      '192.52.193.0/24',
      '192.88.99.0/24',
      '192.168.0.0/16',
      '192.175.48.0/24',
      '198.18.0.0/15',
      '198.51.100.0/24',
      '203.0.113.0/24',
      '240.0.0.0/4',
      '255.255.255.255/32')
    ,
    '16' => array('::1/128',
      '::/128',
      '::ffff:0:0/96',
      '64:ff9b::/96',
      '100::/64',
      '2001::/23',
      '2001::/32',
      '2001:1::1/128',
      '2001:2::/48',
      '2001:3::/32',
      '2001:4:112::/48',
      '2001:5::/32',
      '2001:10::/28',
      '2001:20::/28',
      '2001:db8::/32',
      '2002::/16',
      '2620:4f:8000::/48',
      'fc00::/7',
      'fe80::/10') 
    );

    $ip = inet_pton($ip);
    if( $ip === false ) return false;

    $space='16';
    if (strlen($ip) === 4) { 
      $space='4';
    }

    //Is the IP in a private or special range?
    foreach($networks[$space] as $network) {
      //split $network in address and mask
      $parts=explode('/',$network);
      $network_address = inet_pton($parts[0]);
      $network_mask    = inet_pton( _mask( $ip , $parts[1] ) );
      if (($ip & $network_mask) === $network_address){
        return -1*$space;
      }
    }
    //Success!
    return $space;
}

function _mask($ip,$nbits){
  $mask='';
  $nibble=array('0','8','C','E');
  $f_s= $nbits >> 2 ;
  if( $f_s > 0 ) $mask.=str_repeat('F',$f_s);
  if( $nbits % 4 ) $mask.= $nibble[$nbits % 4];
  if( strlen($ip) === 4 ){
    if( strlen($mask) < 8 ) $mask.=str_repeat('0', 8 - strlen($mask) );
    long2ip('0x'.$mask);
    $mask=long2ip('0x'.$mask);
  }else{
    if( strlen($mask) < 32 ) $mask.=str_repeat('0', 32 - strlen($mask) );
    $mask=rtrim(chunk_split($mask,4,':'),':');
  }
  return $mask;
}

Was ich Frage ist: eine IPv6-Adresse-IPv4-mapped-Address" ist eine "spezielle" Adresse in IPv6-selbst wenn es eine "normale" ip-Adresse in IPv4. Sollten wir eine "private Nutzung" der Subnetze in ::ffff:0:0/96 entsprechen IPv4 private Netzwerke?

BEARBEITEN, zu erklären, die letzten coment:

Dem IPv6-Netzwerk ::ffff:0:0/96 Karten zu einer IPv6-Adresse jeder IPv4-Adresse. Diese IPv6-Adresse in einem einzigen Satz in der IANA registry ("Special-Purpose"), sondern die zugeordneten IPv4-Adressen sind in allen Arten von sets bei IPv4 (private netwok, loopback -, broadcast -,... ) Eine "gemeinsame IPv4-Adresse" ist immer eine "spezielle IPv6-Adresse". Wenn wir ein Netzwerk einrichten Verwendung der IPv6-Adresse ::ffff:0:0/96 Bereich entsprechen IPv4 private Netzwerke... Sind wir mit einem eigenen Netzwerk-Adresse?

InformationsquelleAutor der Antwort miguel-svq

Mit inet_pton statt ip2long, und darunter auch einige der eher obskuren, privaten Bereichen:

function isPublicAddress($ip) {

    //Private ranges...
    //http://www.iana.org/assignments/iana-ipv4-special-registry/
    $networks = array('10.0.0.0'        =>  '255.0.0.0',        //LAN.
                      '172.16.0.0'      =>  '255.240.0.0',      //LAN.
                      '192.168.0.0'     =>  '255.255.0.0',      //LAN.
                      '127.0.0.0'       =>  '255.0.0.0',        //Loopback.
                      '169.254.0.0'     =>  '255.255.0.0',      //Link-local.
                      '100.64.0.0'      =>  '255.192.0.0',      //Carrier.
                      '192.0.2.0'       =>  '255.255.255.0',    //Testing.
                      '198.18.0.0'      =>  '255.254.0.0',      //Testing.
                      '198.51.100.0'    =>  '255.255.255.0',    //Testing.
                      '203.0.113.0'     =>  '255.255.255.0',    //Testing.
                      '192.0.0.0'       =>  '255.255.255.0',    //Reserved.
                      '224.0.0.0'       =>  '224.0.0.0',        //Reserved.
                      '0.0.0.0'         =>  '255.0.0.0');       //Reserved.

    //inet_pton.
    $ip = @inet_pton($ip);
    if (strlen($ip) !== 4) { return false; }

    //Is the IP in a private range?
    foreach($networks as $network_address => $network_mask) {
         $network_address   = inet_pton($network_address);
         $network_mask      = inet_pton($network_mask);
         assert(strlen($network_address)    === 4);
         assert(strlen($network_mask)       === 4);
         if (($ip & $network_mask) === $network_address)
            return false;
    }

    //Success!
    return true;

}

InformationsquelleAutor der Antwort

Grundsätzlich @Mark Davidson Antwort, aber mit etwas Mathematik.

function isPrivate($szAddr) {

   $nIP = ip2long($szAddr);

   $arLocal = [
      [ip2long('127.0.0.0'),   24],
      [ip2long('10.0.0.0'),    24],
      [ip2long('172.16.0.0'),  20],
      [ip2long('192.168.0.0'), 16],
      [ip2long('169.254.0.0'), 16],
   ];

   foreach( $arLocal as $arP ) {

      $maskLo = ~((1 << $arP[1]) - 1);  //CREATE BIT MASK FROM NUMBER

      if( ($nIP & $maskLo) === $arP[0] ) //BITWISE-AND, THEN COMPARE
         return true;
   }

   return false;
}

InformationsquelleAutor der Antwort Jason Stewart

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.