it-swarm.com.de

So erhalten Sie die Client-IP-Adresse in PHP

Wie kann ich die Client-IP-Adresse mit PHP erhalten?

Ich möchte den Benutzer aufzeichnen, der sich über seine IP-Adresse auf meiner Website angemeldet hat.

1106
Anup Prakash

Stellen Sie auf jeden Fall sicher, dass Sie den vom Client gesendeten Daten nicht vertrauen. $_SERVER['REMOTE_ADDR'] enthält die reale IP-Adresse des Verbindungspartners. Das ist der zuverlässigste Wert, den Sie finden können.

Sie können sich jedoch hinter einem Proxyserver befinden. In diesem Fall hat der Proxy möglicherweise den $_SERVER['HTTP_X_FORWARDED_FOR'] festgelegt, dieser Wert kann jedoch leicht gefälscht werden. Beispielsweise kann es von einer Person ohne Proxy festgelegt werden, oder die IP kann eine interne IP aus dem LAN hinter dem Proxy sein.

Dies bedeutet, dass Sie, wenn Sie den $_SERVER['HTTP_X_FORWARDED_FOR'] speichern möchten, sicherstellen müssen, dass Sie auch den $_SERVER['REMOTE_ADDR'] -Wert speichern. Z.B. indem Sie beide Werte in verschiedenen Feldern in Ihrer Datenbank speichern.

Wenn Sie die IP-Adresse als Zeichenfolge in einer Datenbank speichern möchten, stellen Sie sicher, dass mindestens 45 Zeichen Platz haben. IPv6 bleibt erhalten und diese Adressen sind größer als die älteren IPv4-Adressen.

(Beachten Sie, dass IPv6 normalerweise höchstens 39 Zeichen verwendet, aber es gibt auch eine spezielle IPv6-Notation für IPv4-Adressen , die in ihrer vollständigen Form bis zu 45 Zeichen umfassen kann. Wenn Sie also wissen, was Sie tun, können Sie benutze 39 Zeichen, aber wenn du es nur setzen und vergessen willst, benutze 45).

1259
Emil Vikström

$_SERVER['REMOTE_ADDR'] enthält möglicherweise keine echten Client-IP-Adressen, da Sie beispielsweise eine Proxy-Adresse für Clients erhalten, die über einen Proxy verbunden sind. Das ist vielleicht genau das, was Sie wirklich wollen, je nachdem, was Sie mit den IPs machen. Die private RFC1918-Adresse einer anderen Person hilft Ihnen möglicherweise nicht weiter, wenn Sie versuchen festzustellen, woher Ihr Datenverkehr stammt, oder wenn Sie sich merken, von welcher IP der Benutzer zuletzt eine Verbindung hergestellt hat, von welcher öffentlichen IP des Proxys oder von NAT. _ gateway eignet sich möglicherweise besser zum Speichern.

Es gibt mehrere HTTP-Header wie X-Forwarded-For, die von verschiedenen Proxys gesetzt werden können oder nicht. Das Problem ist, dass dies lediglich HTTP-Header sind, die von jedem festgelegt werden können. Es gibt keine Garantie für deren Inhalt. $_SERVER['REMOTE_ADDR'] ist die tatsächliche physische IP-Adresse, von der der Webserver die Verbindung erhalten hat und an die die Antwort gesendet wird. Alles andere ist nur willkürliche und freiwillige Information. Es gibt nur ein Szenario, in dem Sie diesen Informationen vertrauen können: Sie steuern den Proxy, der diesen Header festlegt. Das heißt, nur wenn Sie zu 100% wissen, wo und wie die Kopfzeile gesetzt wurde, sollten Sie sie beachten, wenn etwas von Bedeutung ist.

Vor diesem Hintergrund hier ein Beispielcode:

if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
    $ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
    $ip = $_SERVER['REMOTE_ADDR'];
}

Anmerkung des Herausgebers: Die Verwendung des obigen Codes hat Auswirkungen auf die Sicherheit . Der Client kann alle HTTP-Header-Informationen (z. B. $_SERVER['HTTP_...) auf einen beliebigen Wert setzen. Daher ist es weitaus zuverlässiger, $_SERVER['REMOTE_ADDR'] zu verwenden, da dies nicht vom Benutzer festgelegt werden kann.

Von: http://roshanbh.com.np/2007/12/getting-real-ip-address-in-php.html

420
Tim Kennedy
198
lemon

Hier finden Sie ein übersichtliches Codebeispiel, mit dem Sie die IP-Adresse des Benutzers ermitteln können.

$ip = $_SERVER['HTTP_CLIENT_IP'] ? $_SERVER['HTTP_CLIENT_IP'] : ($_SERVER['HTTP_X_FORWARDED_FOR'] ? $_SERVER['HTTP_X_FORWARDED_FOR'] : $_SERVER['REMOTE_ADDR']);

Hier ist eine kürzere Version, die den elvis-Operator verwendet:

$_SERVER['HTTP_CLIENT_IP'] ? : ($_SERVER['HTTP_X_FORWARDED_FOR'] ? : $_SERVER['REMOTE_ADDR']);

Hier ist eine Version, die isset verwendet, um Benachrichtigungen zu entfernen (danke, @shasi kanth):

$ip = isset($_SERVER['HTTP_CLIENT_IP']) ? $_SERVER['HTTP_CLIENT_IP'] : isset($_SERVER['HTTP_X_FORWARDED_FOR']) ? $_SERVER['HTTP_X_FORWARDED_FOR'] : $_SERVER['REMOTE_ADDR'];
115
josh123a123

Es sollte in der Variablen $_SERVER['REMOTE_ADDR'] enthalten sein.

87
Kyle Cronin

Meine Lieblingslösung ist die Art, wie Zend Framework 2 verwendet wird. Es berücksichtigt auch die $_SERVER -Eigenschaften HTTP_X_FORWARDED_FOR, HTTP_CLIENT_IP, REMOTE_ADDR, deklariert jedoch eine Klasse, um einige vertrauenswürdige Proxys festzulegen, und gibt eine IP-Adresse und kein Array zurück. Ich denke, das ist die Lösung, die ihr am nächsten kommt:

class RemoteAddress
{
    /**
     * Whether to use proxy addresses or not.
     *
     * As default this setting is disabled - IP address is mostly needed to increase
     * security. HTTP_* are not reliable since can easily be spoofed. It can be enabled
     * just for more flexibility, but if user uses proxy to connect to trusted services
     * it's his/her own risk, only reliable field for IP address is $_SERVER['REMOTE_ADDR'].
     *
     * @var bool
     */
    protected $useProxy = false;

    /**
     * List of trusted proxy IP addresses
     *
     * @var array
     */
    protected $trustedProxies = array();

    /**
     * HTTP header to introspect for proxies
     *
     * @var string
     */
    protected $proxyHeader = 'HTTP_X_FORWARDED_FOR';

    // [...]

    /**
     * Returns client IP address.
     *
     * @return string IP address.
     */
    public function getIpAddress()
    {
        $ip = $this->getIpAddressFromProxy();
        if ($ip) {
            return $ip;
        }

        // direct IP address
        if (isset($_SERVER['REMOTE_ADDR'])) {
            return $_SERVER['REMOTE_ADDR'];
        }

        return '';
    }

    /**
     * Attempt to get the IP address for a proxied client
     *
     * @see http://tools.ietf.org/html/draft-ietf-appsawg-http-forwarded-10#section-5.2
     * @return false|string
     */
    protected function getIpAddressFromProxy()
    {
        if (!$this->useProxy
            || (isset($_SERVER['REMOTE_ADDR']) && !in_array($_SERVER['REMOTE_ADDR'], $this->trustedProxies))
        ) {
            return false;
        }

        $header = $this->proxyHeader;
        if (!isset($_SERVER[$header]) || empty($_SERVER[$header])) {
            return false;
        }

        // Extract IPs
        $ips = explode(',', $_SERVER[$header]);
        // trim, so we can compare against trusted proxies properly
        $ips = array_map('trim', $ips);
        // remove trusted proxy IPs
        $ips = array_diff($ips, $this->trustedProxies);

        // Any left?
        if (empty($ips)) {
            return false;
        }

        // Since we've removed any known, trusted proxy servers, the right-most
        // address represents the first IP we do not know about -- i.e., we do
        // not know if it is a proxy server, or a client. As such, we treat it
        // as the originating IP.
        // @see http://en.wikipedia.org/wiki/X-Forwarded-For
        $ip = array_pop($ips);
        return $ip;
    }

    // [...]
}

Den vollständigen Code finden Sie hier: https://raw.githubusercontent.com/zendframework/zend-http/master/src/PhpEnvironment/RemoteAddress.php

52
algorhythm

Es gibt verschiedene Arten von Benutzern hinter dem Internet, daher möchten wir die IP-Adresse aus verschiedenen Bereichen abrufen. Jene sind:

1. $_SERVER['REMOTE_ADDR'] - Enthält die reale IP-Adresse des Clients. Das ist der zuverlässigste Wert, den Sie vom Benutzer finden können.

2. $_SERVER['REMOTE_Host'] - Hiermit wird der Hostname abgerufen, von dem der Benutzer die aktuelle Seite anzeigt. Damit dieses Skript jedoch funktioniert, müssen die Hostnamensuchvorgänge in httpd.conf konfiguriert werden.

. $_SERVER['HTTP_CLIENT_IP'] - Hiermit wird die IP-Adresse abgerufen, wenn der Benutzer von gemeinsam genutzten Internetdiensten stammt.

4. $_SERVER['HTTP_X_FORWARDED_FOR'] - Dies ruft die IP-Adresse vom Benutzer ab, wenn er sich hinter dem Proxy befindet.

Mit der folgenden kombinierten Funktion können wir die reale IP-Adresse von Benutzern abrufen, die an verschiedenen Positionen anzeigen.

// Function to get the user IP address
function getUserIP() {
    $ipaddress = '';
    if (isset($_SERVER['HTTP_CLIENT_IP']))
        $ipaddress = $_SERVER['HTTP_CLIENT_IP'];
    else if(isset($_SERVER['HTTP_X_FORWARDED_FOR']))
        $ipaddress = $_SERVER['HTTP_X_FORWARDED_FOR'];
    else if(isset($_SERVER['HTTP_X_FORWARDED']))
        $ipaddress = $_SERVER['HTTP_X_FORWARDED'];
    else if(isset($_SERVER['HTTP_X_CLUSTER_CLIENT_IP']))
        $ipaddress = $_SERVER['HTTP_X_CLUSTER_CLIENT_IP'];
    else if(isset($_SERVER['HTTP_FORWARDED_FOR']))
        $ipaddress = $_SERVER['HTTP_FORWARDED_FOR'];
    else if(isset($_SERVER['HTTP_FORWARDED']))
        $ipaddress = $_SERVER['HTTP_FORWARDED'];
    else if(isset($_SERVER['REMOTE_ADDR']))
        $ipaddress = $_SERVER['REMOTE_ADDR'];
    else
        $ipaddress = 'UNKNOWN';
    return $ipaddress;
}
44
K.Suthagar

Das Folgende ist die fortschrittlichste Methode, die ich gefunden habe, und ich habe bereits einige andere ausprobiert. Es gilt sicherzustellen, dass die IP-Adresse eines Besuchers abgerufen wird (bitte beachten Sie jedoch, dass jeder Hacker die IP-Adresse leicht verfälschen kann).

function get_ip_address() {

    // Check for shared Internet/ISP IP
    if (!empty($_SERVER['HTTP_CLIENT_IP']) && validate_ip($_SERVER['HTTP_CLIENT_IP'])) {
        return $_SERVER['HTTP_CLIENT_IP'];
    }

    // Check for IP addresses passing through proxies
    if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {

        // Check if multiple IP addresses exist in var
        if (strpos($_SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false) {
            $iplist = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
            foreach ($iplist as $ip) {
                if (validate_ip($ip))
                    return $ip;
            }
        }
        else {
            if (validate_ip($_SERVER['HTTP_X_FORWARDED_FOR']))
                return $_SERVER['HTTP_X_FORWARDED_FOR'];
        }
    }
    if (!empty($_SERVER['HTTP_X_FORWARDED']) && validate_ip($_SERVER['HTTP_X_FORWARDED']))
        return $_SERVER['HTTP_X_FORWARDED'];
    if (!empty($_SERVER['HTTP_X_CLUSTER_CLIENT_IP']) && validate_ip($_SERVER['HTTP_X_CLUSTER_CLIENT_IP']))
        return $_SERVER['HTTP_X_CLUSTER_CLIENT_IP'];
    if (!empty($_SERVER['HTTP_FORWARDED_FOR']) && validate_ip($_SERVER['HTTP_FORWARDED_FOR']))
        return $_SERVER['HTTP_FORWARDED_FOR'];
    if (!empty($_SERVER['HTTP_FORWARDED']) && validate_ip($_SERVER['HTTP_FORWARDED']))
        return $_SERVER['HTTP_FORWARDED'];

    // Return unreliable IP address since all else failed
    return $_SERVER['REMOTE_ADDR'];
}

/**
 * Ensures an IP address is both a valid IP address and does not fall within
 * a private network range.
 */
function validate_ip($ip) {

    if (strtolower($ip) === 'unknown')
        return false;

    // Generate IPv4 network address
    $ip = ip2long($ip);

    // If the IP address is set and not equivalent to 255.255.255.255
    if ($ip !== false && $ip !== -1) {
        // Make sure to get unsigned long representation of IP address
        // due to discrepancies between 32 and 64 bit OSes and
        // signed numbers (ints default to signed in PHP)
        $ip = sprintf('%u', $ip);

        // Do private network range checking
        if ($ip >= 0 && $ip <= 50331647)
            return false;
        if ($ip >= 167772160 && $ip <= 184549375)
            return false;
        if ($ip >= 2130706432 && $ip <= 2147483647)
            return false;
        if ($ip >= 2851995648 && $ip <= 2852061183)
            return false;
        if ($ip >= 2886729728 && $ip <= 2887778303)
            return false;
        if ($ip >= 3221225984 && $ip <= 3221226239)
            return false;
        if ($ip >= 3232235520 && $ip <= 3232301055)
            return false;
        if ($ip >= 4294967040)
            return false;
    }
    return true;
}
34
manuelbcd

Die Antwort lautet $_SERVER Variable. Beispielsweise würde _$_SERVER["REMOTE_ADDR"]_ die IP-Adresse des Clients zurückgeben.

30
kainosnous

Wie bereits erwähnt, können Sie $_SERVER['REMOTE_ADDR']; verwenden, um die Client-IP-Adresse abzurufen.

Wenn Sie weitere Informationen zu einem Benutzer benötigen, können Sie Folgendes verwenden:

<?php
    $ip = '0.0.0.0';
    $ip = $_SERVER['REMOTE_ADDR'];
    $clientDetails = json_decode(file_get_contents("http://ipinfo.io/$ip/json"));
    echo "You're logged in from: <b>" . $clientDetails->country . "</b>";
?>

Weitere Informationen zum Client finden Sie in $ clientDetails.
Sie können JSON-Elemente, die in der Variablen $ clientDetails gespeichert sind, folgendermaßen abrufen: $ clientDetails-> Postleitzahl/Hostname/Region/Ort ...

Ich benutze ipinfo.io um zusätzliche Informationen zu erhalten.

11
Siamak SiaSoft

Dies ist die Methode, die ich verwende und die eine IPv4 -Eingabe validiert:

// Get user IP address
if ( isset($_SERVER['HTTP_CLIENT_IP']) && ! empty($_SERVER['HTTP_CLIENT_IP'])) {
    $ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif ( isset($_SERVER['HTTP_X_FORWARDED_FOR']) && ! empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
    $ip = (isset($_SERVER['REMOTE_ADDR'])) ? $_SERVER['REMOTE_ADDR'] : '0.0.0.0';
}

$ip = filter_var($ip, FILTER_VALIDATE_IP);
$ip = ($ip === false) ? '0.0.0.0' : $ip;
10
carbontwelve
$ip = "";

if (!empty($_SERVER["HTTP_CLIENT_IP"]))
{
    // Check for IP address from shared Internet
    $ip = $_SERVER["HTTP_CLIENT_IP"];
}
elseif (!empty($_SERVER["HTTP_X_FORWARDED_FOR"]))
{
    // Check for the proxy user
    $ip = $_SERVER["HTTP_X_FORWARDED_FOR"];
}
else
{
    $ip = $_SERVER["REMOTE_ADDR"];
}
echo $ip;
10
Mahfuz Ahmed

Probier diese:

 $_SERVER['REMOTE_ADDR'];

Dies kann einfach mithilfe der Variablen GLOBAL mit dem Namen $_SERVER erfolgen.

Der $_SERVER ist ein Array mit dem Attributnamen REMOTE_ADDR.

Weisen Sie es einfach so zu:

$userIp = $_SERVER['REMOTE_ADDR'];

Oder verwenden Sie es direkt wie echo $_SERVER['REMOTE_ADDR']; oder echo ($_SERVER['REMOTE_ADDR']);.

9

Ich mag diesen Codesnippet:

function getClientIP() {

    if (isset($_SERVER)) {

        if (isset($_SERVER["HTTP_X_FORWARDED_FOR"]))
            return $_SERVER["HTTP_X_FORWARDED_FOR"];

        if (isset($_SERVER["HTTP_CLIENT_IP"]))
            return $_SERVER["HTTP_CLIENT_IP"];

        return $_SERVER["REMOTE_ADDR"];
    }

    if (getenv('HTTP_X_FORWARDED_FOR'))
        return getenv('HTTP_X_FORWARDED_FOR');

    if (getenv('HTTP_CLIENT_IP'))
        return getenv('HTTP_CLIENT_IP');

    return getenv('REMOTE_ADDR');
}
9
Johan Wikström

Die folgende Funktion ermittelt alle Möglichkeiten und gibt die Werte in einem durch Kommas getrennten Format zurück (ip, ip usw.).

Es hat auch eine optionale Validierungsfunktion als (erster Parameter, der standardmäßig deaktiviert ist), um die IP-Adresse anhand (privater Bereich und reservierter Bereich) zu validieren.

<?php
echo GetClientIP(true);

function GetClientIP($validate = False) {
  $ipkeys = array(
  'REMOTE_ADDR',
  'HTTP_CLIENT_IP',
  'HTTP_X_FORWARDED_FOR',
  'HTTP_X_FORWARDED',
  'HTTP_FORWARDED_FOR',
  'HTTP_FORWARDED',
  'HTTP_X_CLUSTER_CLIENT_IP'
  );

  /*
  Now we check each key against $_SERVER if containing such value
  */
  $ip = array();
  foreach ($ipkeys as $keyword) {
    if (isset($_SERVER[$keyword])) {
      if ($validate) {
        if (ValidatePublicIP($_SERVER[$keyword])) {
          $ip[] = $_SERVER[$keyword];
        }
      }
      else{
        $ip[] = $_SERVER[$keyword];
      }
    }
  }

  $ip = ( empty($ip) ? 'Unknown' : implode(", ", $ip) );
  return $ip;
}

function ValidatePublicIP($ip){
  if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
    return true;
  }
  else {
    return false;
  }
}
5
Akam

Diese Funktion ist kompakt und kann überall verwendet werden. Aber!

Vergiss das nicht! Bei dieser Art von Funktionen oder Codeblöcken gibt es keine Garantie für die Aufzeichnung der tatsächlichen IP-Adresse des Benutzers, da einige Benutzer einen Proxy oder ein anderes sicheres Gateway verwenden können, um unsichtbar zu sein, oder nicht nachverfolgen können

PHP-Funktion:

function GetIP()
{
    if ( getenv("HTTP_CLIENT_IP") ) {
        $ip = getenv("HTTP_CLIENT_IP");
    } elseif ( getenv("HTTP_X_FORWARDED_FOR") ) {
        $ip = getenv("HTTP_X_FORWARDED_FOR");
        if ( strstr($ip, ',') ) {
            $tmp = explode(',', $ip);
            $ip = trim($tmp[0]);
        }
    } else {
        $ip = getenv("REMOTE_ADDR");
    }
    return $ip;
}

Verwendungszweck:

$IP = GetIP(); oder direkt GetIP();

5
Ivan Barayev

Sicheres und warnendes Snippet zum Abrufen der IP-Adresse:

$ip = filter_input(INPUT_SERVER, 'HTTP_CLIENT_IP', FILTER_VALIDATE_IP)
    ?: filter_input(INPUT_SERVER, 'HTTP_X_FORWARDED_FOR', FILTER_VALIDATE_IP)
    ?: $_SERVER['REMOTE_ADDR']
    ?? '0.0.0.0'; // Or other value fits "not defined" in your logic
4

Diese Funktion sollte wie erwartet funktionieren

function Get_User_Ip()
{
    $IP = false;
    if (getenv('HTTP_CLIENT_IP'))
    {
        $IP = getenv('HTTP_CLIENT_IP');
    }
    else if(getenv('HTTP_X_FORWARDED_FOR'))
    {
        $IP = getenv('HTTP_X_FORWARDED_FOR');
    }
    else if(getenv('HTTP_X_FORWARDED'))
    {
        $IP = getenv('HTTP_X_FORWARDED');
    }
    else if(getenv('HTTP_FORWARDED_FOR'))
    {
        $IP = getenv('HTTP_FORWARDED_FOR');
    }
    else if(getenv('HTTP_FORWARDED'))
    {
        $IP = getenv('HTTP_FORWARDED');
    }
    else if(getenv('REMOTE_ADDR'))
    {
        $IP = getenv('REMOTE_ADDR');
    }

    //If HTTP_X_FORWARDED_FOR == server ip
    if((($IP) && ($IP == getenv('SERVER_ADDR')) && (getenv('REMOTE_ADDR')) || (!filter_var($IP, FILTER_VALIDATE_IP))))
    {
        $IP = getenv('REMOTE_ADDR');
    }

    if($IP)
    {
        if(!filter_var($IP, FILTER_VALIDATE_IP))
        {
            $IP = false;
        }
    }
    else
    {
        $IP = false;
    }
    return $IP;
}
2

Eine schnelle Lösung (fehlerfrei)

function getClientIP()
{
    $ipaddress = 'UNKNOWN';
    $keys=array('HTTP_CLIENT_IP','HTTP_X_FORWARDED_FOR','HTTP_X_FORWARDED','HTTP_FORWARDED_FOR','HTTP_FORWARDED','REMOTE_ADDR');
    foreach($keys as $k)
    {
        if (isset($_SERVER[$k]) && !empty($_SERVER[$k]) && filter_var($_SERVER[$k], FILTER_VALIDATE_IP))
        {
            $ipaddress = $_SERVER[$k];
            break;
        }
    }
    return $ipaddress;
}
2
Stergios Zg.

Einer von diesen :

    $ip = $_SERVER['REMOTE_ADDR'];
    $ip = $_SERVER['HTTP_CLIENT_IP'];
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
    $ip = $_SERVER['HTTP_X_FORWARDED'];
    $ip = $_SERVER['HTTP_FORWARDED_FOR'];
    $ip = $_SERVER['HTTP_FORWARDED'];
1
SIE

Hier ist die einzeilige Version, die die IP-Adresse des Kunden abruft:

$ip = @$_SERVER['HTTP_CLIENT_IP'] ?: @$_SERVER['HTTP_X_FORWARDED_FOR'] ?: @$_SERVER['REMOTE_ADDR'];

Anmerkungen:

  • Durch die Verwendung von @ werden die PHP Hinweise unterdrückt.
  • Der Wert von HTTP_X_FORWARDED_FOR kann aus mehreren durch Komma getrennten Adressen bestehen. Wenn Sie also die erste Adresse erhalten möchten, können Sie die folgende Methode verwenden:

    current(explode(',', @$_SERVER['HTTP_X_FORWARDED_FOR']))
    
1
kenorb
function get_client_ip() 
{
   $ipaddress = '';
    if (getenv('HTTP_CLIENT_IP'))
        $ipaddress = getenv('HTTP_CLIENT_IP');
    else if(getenv('HTTP_X_FORWARDED_FOR'))
        $ipaddress = getenv('HTTP_X_FORWARDED_FOR');
    else if(getenv('HTTP_X_FORWARDED'))
        $ipaddress = getenv('HTTP_X_FORWARDED');
    else if(getenv('HTTP_FORWARDED_FOR'))
        $ipaddress = getenv('HTTP_FORWARDED_FOR');
    else if(getenv('HTTP_FORWARDED'))
       $ipaddress = getenv('HTTP_FORWARDED');
    else if(getenv('REMOTE_ADDR'))
        $ipaddress = getenv('REMOTE_ADDR');
    else
        $ipaddress = 'UNKNOWN';

   return $ipaddress;
} 
1
Masoud Siahkali

Hier ist ein bisschen Code, der eine gültige IP-Überprüfung durch verschiedene Quellen auswählen sollte.

Zuerst wird geprüft, ob 'REMOTE_ADDR' eine öffentliche IP ist oder nicht (und nicht einer Ihrer vertrauenswürdigen Reverse-Proxys), dann wird einer der HTTP-Header durchsucht, bis eine öffentliche IP gefunden und diese zurückgegeben wird. (PHP 5.2+)

Es sollte zuverlässig sein, solange der Reverse-Proxy vertrauenswürdig ist oder der Server direkt mit dem Client verbunden ist.

//Get client's IP or null if nothing looks valid
function ip_get($allow_private = false)
{
  //Place your trusted proxy server IPs here.
  $proxy_ip = ['127.0.0.1'];

  //The header to look for (Make sure to pick the one that your trusted reverse proxy is sending or else you can get spoofed)
  $header = 'HTTP_X_FORWARDED_FOR'; //HTTP_CLIENT_IP, HTTP_X_FORWARDED, HTTP_FORWARDED_FOR, HTTP_FORWARDED

  //If 'REMOTE_ADDR' seems to be a valid client IP, use it.
  if(ip_check($_SERVER['REMOTE_ADDR'], $allow_private, $proxy_ip)) return $_SERVER['REMOTE_ADDR'];

  if(isset($_SERVER[$header]))
  {
    //Split comma separated values [1] in the header and traverse the proxy chain backwards.
    //[1] https://en.wikipedia.org/wiki/X-Forwarded-For#Format
    $chain = array_reverse(preg_split('/\s*,\s*/', $_SERVER[$header]));
    foreach($chain as $ip) if(ip_check($ip, $allow_private, $proxy_ip)) return $ip;
  }

   return null;
}

//Check for valid IP. If 'allow_private' flag is set to truthy, it allows private IP ranges as valid client IP as well. (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16)
//Pass your trusted reverse proxy IPs as $proxy_ip to exclude them from being valid.
function ip_check($ip, $allow_private = false, $proxy_ip = [])
{
  if(!is_string($ip) || is_array($proxy_ip) && in_array($ip, $proxy_ip)) return false;
  $filter_flag = FILTER_FLAG_NO_RES_RANGE;

  if(!$allow_private)
  {
    //Disallow loopback IP range which doesn't get filtered via 'FILTER_FLAG_NO_PRIV_RANGE' [1]
    //[1] https://www.php.net/manual/en/filter.filters.validate.php
    if(preg_match('/^127\.$/', $ip)) return false;
    $filter_flag |= FILTER_FLAG_NO_PRIV_RANGE;
  }

  return filter_var($ip, FILTER_VALIDATE_IP, $filter_flag) !== false;
}
1
windware-ono
$_SERVER['REMOTE_ADDR'];

Beispiel:

if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
    $ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
    $ip = $_SERVER['REMOTE_ADDR'];
}
0
Suresh Ratten
function get_client_ip()
{
    foreach (array(
                'HTTP_CLIENT_IP',
                'HTTP_X_FORWARDED_FOR',
                'HTTP_X_FORWARDED',
                'HTTP_X_CLUSTER_CLIENT_IP',
                'HTTP_FORWARDED_FOR',
                'HTTP_FORWARDED',
                'REMOTE_ADDR') as $key) {
        if (array_key_exists($key, $_SERVER)) {
            foreach (explode(',', $_SERVER[$key]) as $ip) {
                $ip = trim($ip);
                if ((bool) filter_var($ip, FILTER_VALIDATE_IP,
                                FILTER_FLAG_IPV4 |
                                FILTER_FLAG_NO_PRIV_RANGE |
                                FILTER_FLAG_NO_RES_RANGE)) {
                    return $ip;
                }
            }
        }
    }
    return null;
}

Oder die komprimierte Version:

function get_ip() {
    foreach (array('HTTP_CLIENT_IP', 'HTTP_X_FORWARDED_FOR', 'HTTP_X_FORWARDED', 'HTTP_X_CLUSTER_CLIENT_IP', 'HTTP_FORWARDED_FOR', 'HTTP_FORWARDED', 'REMOTE_ADDR') as $key) {
        if (array_key_exists($key, $_SERVER) === true) {
            foreach (array_map('trim', explode(',', $_SERVER[$key])) as $ip) {
                if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false) {
                    return $ip;
                }
            }
        }
    }
}

0
nowheretoseek

Ich bin überrascht, dass es noch nicht erwähnt wurde, die korrekten IP-Adressen der Sites abzurufen, die sich hinter CloudFlare-Infrastrukturen befinden. Dadurch werden Ihre IP-Adressen getrennt und erhalten alle denselben Wert. Zum Glück gibt es auch einige Serverheader. Anstatt dass ich das bereits Geschriebene neu schreibe, schaue ich hier nach einer präziseren Antwort, und ja, ich habe diesen Prozess auch schon vor langer Zeit durchlaufen. https://stackoverflow.com/a/14985633/1190051

0
vr_driver
// Function to get the client ip address
function get_ip() 
{

if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
    $ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
    $ip = $_SERVER['REMOTE_ADDR'];
}
return $ip;


}
0
user8031209

Hier ist ein einfacher Einzeiler

$ip = $_SERVER['HTTP_X_FORWARDED_FOR']?: $_SERVER['HTTP_CLIENT_IP']?: $_SERVER['REMOTE_ADDR'];

BEARBEITEN:

Der obige Code kann reservierte Adressen (wie 10.0.0.1), Adressenliste aller Proxy-Server auf dem Weg usw. zurückgeben. Um diese Fälle zu behandeln, verwenden Sie den folgenden Code:

function valid_ip($ip) {
    // for list of reserved IP addresses, see https://en.wikipedia.org/wiki/Reserved_IP_addresses
    return $ip && substr($ip, 0, 4) != '127.' && substr($ip, 0, 4) != '127.' && substr($ip, 0, 3) != '10.' && substr($ip, 0, 2) != '0.' ? $ip : false;
}

function get_client_ip() {
    // using explode to get only client ip from list of forwarders. see https://en.wikipedia.org/wiki/X-Forwarded-For
    return
    @$_SERVER['HTTP_X_FORWARDED_FOR'] ? explode(',', $_SERVER['HTTP_X_FORWARDED_FOR'], 2)[0] :
    @$_SERVER['HTTP_CLIENT_IP'] ? explode(',', $_SERVER['HTTP_CLIENT_IP'], 2)[0] :
    valid_ip(@$_SERVER['REMOTE_ADDR']) ?:
    'UNKNOWN';
}

echo get_client_ip();
0
oriadam

Wie das folgende?

if (($ip=filter_input(INPUT_SERVER, 'REMOTE_ADDR', validate_ip)) === false or empty($ip)) {
    exit;
}
echo $ip;

PS

if (($ip=filter_input(INPUT_SERVER, 'REMOTE_ADDR', FILTER_VALIDATE_IP|FILTER_FLAG_NO_PRIV_RANGE|FILTER_FLAG_NO_RES_RANGE)) === false) {
    header('HTTP/1.0 400 Bad Request');
    exit;
}

Alle Header, die mit 'HTTP_' oder 'X-' beginnen, können gefälscht werden. Dies ist benutzerdefiniert. Wenn Sie den Überblick behalten möchten, verwenden Sie Cookies usw.

0
B.F.