Question Comment obtenir l'adresse IP du client en PHP?


Comment puis-je obtenir l'adresse IP du client en utilisant PHP?

Je veux garder trace de l'utilisateur qui s'est connecté à mon site Web via son adresse IP.


977
2018-06-09 04:50


origine


Réponses:


Quoi que vous fassiez, assurez-vous de ne pas faire confiance aux données envoyées par le client. $_SERVER['REMOTE_ADDR'] contient l'adresse IP réelle de la partie qui se connecte. C'est la valeur la plus fiable que vous pouvez trouver.

Cependant, ils peuvent être derrière un serveur proxy auquel cas le proxy peut avoir défini $_SERVER['HTTP_X_FORWARDED_FOR'], mais cette valeur est facilement usurpée. Par exemple, il peut être défini par une personne sans proxy ou l'adresse IP peut être une adresse IP interne du réseau local derrière le proxy.

Cela signifie que si vous allez enregistrer le $_SERVER['HTTP_X_FORWARDED_FOR'], assurez-vous aussi sauver la $_SERVER['REMOTE_ADDR'] valeur. Par exemple. en enregistrant les deux valeurs dans différents champs de votre base de données.

Si vous souhaitez enregistrer l'adresse IP dans une base de données sous forme de chaîne, assurez-vous d'avoir au moins 45 caractères. IPv6 est là pour rester et ces adresses sont plus grandes que les anciennes adresses IPv4.

(Notez que IPv6 utilise habituellement 39 caractères au maximum, mais il y a aussi un Notation IPv6 pour les adresses IPv4 qui dans sa forme complète peut être jusqu'à 45 caractères. Donc, si vous savez ce que vous faites, vous pouvez utiliser 39 caractères, mais si vous voulez juste le définir et l'oublier, utilisez 45).


1163
2018-06-09 05:15



$_SERVER['REMOTE_ADDR'] peut ne pas contenir réellement les adresses IP des clients réels, car il vous donnera une adresse proxy pour les clients connectés via un proxy, par exemple. Cela peut Bien sois ce que tu veux vraiment, en fonction de ce que tu fais avec les IP. L'adresse RFC1918 privée de quelqu'un peut ne pas vous faire du bien si vous dites, en essayant de voir d'où votre trafic provient, ou en se rappelant de quelle IP l'utilisateur s'est connecté en dernier, où l'IP public du proxy ou de la passerelle NAT approprié pour stocker.

Il y a plusieurs en-têtes HTTP comme X-Forwarded-For qui peut ou non être fixé par divers procurations. Le problème est que ce sont simplement des en-têtes HTTP qui peuvent être définis par n'importe qui. Il n'y a aucune garantie sur leur contenu. $_SERVER['REMOTE_ADDR'] est l'adresse IP physique réelle à partir de laquelle le serveur Web a reçu la connexion et à laquelle la réponse sera envoyée. Tout le reste n'est que de l'information arbitraire et volontaire. Il existe un seul scénario dans lequel vous pouvez faire confiance à cette information: vous contrôlez le proxy qui définit cet en-tête. Ce qui signifie que si vous savez 100% où et comment l'en-tête a été défini, vous devez le tenir compte de tout ce qui est important.

Cela dit, voici un exemple de code:

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'];
}

Note de l'éditeur: L'utilisation du code ci-dessus a implications pour la sécurité. Le client peut définir toutes les informations d'en-tête HTTP (ie. $_SERVER['HTTP_...) à toute valeur arbitraire qu'il veut. En tant que tel, il est beaucoup plus fiable à utiliser $_SERVER['REMOTE_ADDR'], car cela ne peut pas être défini par l'utilisateur.

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


376
2017-09-11 04:01



echo $_SERVER['REMOTE_ADDR'];

http://php.net/manual/en/reserved.variables.server.php


185
2018-06-09 04:51



Il devrait être contenu dans le $_SERVER['REMOTE_ADDR'] variable.


79
2017-09-11 03:38



Voici un exemple de code plus propre d'un bon moyen d'obtenir l'adresse IP de l'utilisateur.

$ip = $_SERVER['HTTP_CLIENT_IP']?$_SERVER['HTTP_CLIENT_IP']:($_SERVER['HTTP_X_FORWARDE‌​D_FOR']?$_SERVER['HTTP_X_FORWARDED_FOR']:$_SERVER['REMOTE_ADDR']);

Voici une version plus courte qui utilise l'opérateur elvis

$_SERVER['HTTP_CLIENT_IP']?:($_SERVER['HTTP_X_FORWARDE‌​D_FOR']?:$_SERVER['REMOTE_ADDR']);

Voici une version qui utilise isset pour supprimer les notifications (merci, @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'];

79
2017-10-08 16:20



Ma solution préférée est la façon dont Zend Framework 2 utilise. Il considère également $_SERVER Propriétés HTTP_X_FORWARDED_FOR, HTTP_CLIENT_IP, REMOTE_ADDR mais il déclare une classe pour définir des proxies de confiance et renvoie une adresse IP et non un tableau. Je pense que c'est la solution qui s'en rapproche le plus:

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;
    }

    // [...]
}

Voir le code complet ici: https://raw.githubusercontent.com/zendframework/zend-http/master/src/PhpEnvironment/RemoteAddress.php


47
2017-07-07 09:02



Il existe différents types d'utilisateurs derrière Internet, donc nous voulons attraper l'adresse IP de différentes potions. Qui sont,

1. $_SERVER['REMOTE_ADDR'] - Cela contient la véritable adresse IP du client. C'est la valeur la plus fiable que vous pouvez trouver auprès de l'utilisateur.

2. $_SERVER['REMOTE_HOST'] - Cela va chercher le nom d'hôte à partir duquel l'utilisateur visualise la page en cours. Mais pour que ce script fonctionne, les recherches de nom d'hôte dans httpd.conf doivent être configurées.

3. $_SERVER['HTTP_CLIENT_IP'] - Cela ira chercher l'adresse IP lorsque l'utilisateur provient de services Internet partagés.

4. $_SERVER['HTTP_X_FORWARDED_FOR'] - Cela va chercher l'adresse IP de l'utilisateur quand il est derrière le proxy

Nous pouvons donc utiliser cette fonction combinée suivante pour obtenir l'adresse IP réelle des utilisateurs qui sont dans différentes positions,

// 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;
}

34
2017-12-29 15:18



C'est la méthode la plus avancée que j'ai trouvée, déjà essayée par d'autres dans le passé. Valide pour s'assurer d'obtenir l'adresse IP du visiteur (mais s'il vous plaît noter que n'importe quel hacker pourrait falsifier l'adresse IP facilement).

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 IPs passing through proxies
    if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
        // check if multiple ips 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 since all else failed
    return $_SERVER['REMOTE_ADDR'];
}

/**
 * Ensures an ip address is both a valid IP 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 is set and not equivalent to 255.255.255.255
    if ($ip !== false && $ip !== -1) {
        // make sure to get unsigned long representation of ip
        // 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;
}

la source: http://blackbe.lt/advanced-method-to-obtain-the-client-ip-in-php/


29
2018-01-29 14:37



La réponse est d'utiliser $_SERVER variable. Par exemple, $_SERVER["REMOTE_ADDR"] retournerait l'adresse IP du client.


26
2018-06-09 04:56



C'est la méthode que j'utilise, et elle valide un IPv4 contribution:

// 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;

9
2018-02-13 14:47



$ip = "";

if (!empty($_SERVER["HTTP_CLIENT_IP"]))
{
 //check for ip from share 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;

9
2017-12-28 10:50