nombre - ¿Cómo obtener la dirección IP del cliente en PHP?

obtener nombre de equipo cliente php

Question

¿Cómo puedo obtener la dirección IP del cliente usando PHP?

Quiero mantener un registro del usuario que inició sesión en mi sitio web a través de su dirección IP.

Answer 1

¿¿¿¿Como eso????

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

PD

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

Todos los encabezados que comienzan con ''HTTP_'' o ''X-'' pueden ser falsificados, respectivamente, están definidos por el usuario. Si quieres mantener un seguimiento usa cooies etc.

Answer 2

Aquí está la versión de una sola línea que obtiene la dirección IP del cliente:

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

Notas:

• Al usar @ , suprime los avisos de PHP.

• El valor de HTTP_X_FORWARDED_FOR puede consistir en varias direcciones separadas por comas, por lo que si prefiere obtener la primera, puede usar el siguiente método:

  current(explode('','', @$_SERVER[''HTTP_X_FORWARDED_FOR'']))

Answer 3

Aquí hay un ejemplo de código más limpio de una buena manera de obtener la ip del usuario.

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

Aquí hay una versión más corta que utiliza el operador elvis.

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

Aquí hay una versión que usa isset para eliminar avisos (gracias, @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''];

Answer 4

Aquí hay un simple forro

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

EDITAR:

El código anterior puede devolver direcciones reservadas (como 10.0.0.1), una lista de direcciones de todos los servidores proxy en camino, etc. Para manejar estos casos, use el siguiente código:

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();

Answer 5

Bueno, esto se puede hacer simplemente usando la variable GLOBAL nombrada como $_SERVER .

$_SERVER es una matriz que tiene un nombre de atributo REMOTE_ADDR .

Solo $userIp = $_SERVER[''REMOTE_ADDR'']; esta forma $userIp = $_SERVER[''REMOTE_ADDR''];

o echo $_SERVER[''REMOTE_ADDR'']; directamente como echo $_SERVER[''REMOTE_ADDR'']; o echo ($_SERVER[''REMOTE_ADDR'']);

Answer 6

Como todos los demás dijeron antes, puede usar $_SERVER[''REMOTE_ADDR'']; para obtener la dirección IP del cliente.

Además, si necesita más información sobre un usuario, puede usar esto:

<?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>";
?>

La información más específica del cliente entra en $ clientDetails.
Puede obtener los elementos json almacenados en la variable $ clientDetails de esta manera: $ clientDetails-> PostalCode / hostname / region / loc ...

Estoy usando ipinfo.io para obtener información adicional.

Espero que ayude.

Answer 7

Debe estar contenido en la variable $_SERVER[''REMOTE_ADDR''] .

Answer 8

Esta función es compacta y puedes usarla en todas partes. Pero !

¡No olvides esto! En este tipo, las funciones o los bloques de código no garantizan el registro de la IP real del usuario porque algunos usuarios pueden usar proxy u otras puertas de enlace seguras para ser invisibles o no pueden rastrearse

Función de php:

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

Uso:

$IP = GetIP(); o directamente GetIP();

Answer 9

Este es el método más avanzado que he encontrado, ya probé algunos otros en el pasado. Válido para asegurarse de obtener la dirección IP del visitante (pero tenga en cuenta que cualquier pirata informático podría falsificar la dirección IP fácilmente).

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

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

Answer 10

Este es el método que utilizo, y valida una entrada de IPv4 :

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

Answer 11

Fragmento seguro y con advertencias para obtener IP:

$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

Answer 12

Hay diferentes tipos de usuarios detrás de Internet, así que queremos capturar la dirección IP de diferentes pociones. Que son,

1. $_SERVER[''REMOTE_ADDR''] : contiene la dirección IP real del cliente. Ese es el valor más confiable que puede encontrar del usuario.

2. $_SERVER[''REMOTE_HOST''] - $_SERVER[''REMOTE_HOST''] el nombre del host desde el cual el usuario está viendo la página actual. Pero para que esta secuencia de comandos funcione, se deben configurar las búsquedas de nombre de host en httpd.conf.

3. $_SERVER[''HTTP_CLIENT_IP''] - $_SERVER[''HTTP_CLIENT_IP''] la dirección IP cuando el usuario sea de los servicios de Internet compartidos.

4. $_SERVER[''HTTP_X_FORWARDED_FOR''] - Esto obtendrá la dirección IP del usuario cuando esté detrás del proxy

Así que podemos usar esta siguiente función combinada para obtener la dirección IP real de los usuarios que están viendo en diferentes posiciones,

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

Answer 13

La respuesta es usar la variable $_SERVER . Por ejemplo, $_SERVER["REMOTE_ADDR"] devolvería la dirección IP del cliente.

Answer 14

La siguiente función determina todas las posibilidades y devuelve el valor en coma separada (ip, ip, etc.).

También tiene una función de validación opcional como (primer parámetro que está deshabilitado de forma predeterminada) para validar la dirección IP en contra (rango privado y rango reservado).

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

Answer 15

Me gusta este codenippet

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

Answer 16

Mi solución favorita es la forma en que usa Zend Framework 2. También considera las propiedades $_SERVER HTTP_X_FORWARDED_FOR , HTTP_CLIENT_IP , REMOTE_ADDR pero declara una clase para que establezca algunos servidores proxy de confianza y devuelve una dirección IP no una matriz. Creo que esta es la solución que más se acerca a ella:

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

    // [...]
}

Vea el código completo aquí: https://raw.githubusercontent.com/zendframework/zend-http/master/src/PhpEnvironment/RemoteAddress.php

Answer 17

$_SERVER[''REMOTE_ADDR''] puede no contener realmente direcciones IP de clientes reales, ya que le dará una dirección proxy para los clientes conectados a través de un proxy, por ejemplo. Sin embargo, eso puede ser lo que realmente quieres, dependiendo de lo que estés haciendo con las IP. La dirección privada de RFC1918 de alguien puede no servirle de nada si trata de ver desde dónde se origina su tráfico, o recordar a qué IP se conectó el usuario por última vez, donde la IP pública del proxy o la puerta de enlace NAT puede ser más apropiado para almacenar.

Hay varios encabezados HTTP, como X-Forwarded-For que pueden ser o no configurados por varios proxies. El problema es que esos son simplemente encabezados HTTP que pueden ser configurados por cualquier persona. No hay garantía sobre su contenido. $_SERVER[''REMOTE_ADDR''] es la dirección IP física real desde la cual el servidor web recibió la conexión y a la que se enviará la respuesta. Cualquier otra cosa es información arbitraria y voluntaria. Solo hay un escenario en el que puedes confiar en esta información: estás controlando el proxy que establece este encabezado. Es decir, solo si sabe al 100% dónde y cómo se colocó el encabezado debería prestar atención a cualquier cosa de importancia.

Dicho esto, aquí hay un código de ejemplo:

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

Nota del editor: el uso del código anterior tiene implicaciones de seguridad . El cliente puede configurar toda la información del encabezado HTTP (es decir, $_SERVER[''HTTP_... ) a cualquier valor arbitrario que desee. Como tal, es mucho más confiable usar $_SERVER[''REMOTE_ADDR''] , ya que el usuario no puede configurar esto.

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

Answer 18

Hagas lo que hagas, asegúrate de no confiar en los datos enviados desde el cliente. $_SERVER[''REMOTE_ADDR''] contiene la dirección IP real del interlocutor. Ese es el valor más confiable que puedes encontrar.

Sin embargo, pueden estar detrás de un servidor proxy, en cuyo caso el proxy puede haber configurado $_SERVER[''HTTP_X_FORWARDED_FOR''] , pero este valor es fácil de falsificar. Por ejemplo, puede ser establecido por alguien sin un proxy, o la IP puede ser una IP interna desde la LAN detrás del proxy.

Esto significa que si va a guardar $_SERVER[''HTTP_X_FORWARDED_FOR''] , asegúrese de guardar también el $_SERVER[''REMOTE_ADDR''] . Por ejemplo, guardando ambos valores en diferentes campos en su base de datos.

Si va a guardar la IP en una base de datos como una cadena, asegúrese de tener espacio para al menos 45 caracteres . IPv6 está aquí para quedarse y esas direcciones son más grandes que las antiguas direcciones IPv4.

(Tenga en cuenta que IPv6 usualmente usa 39 caracteres como máximo, pero también hay una notación especial de IPv6 para las direcciones IPv4 que en su forma completa puede tener hasta 45 caracteres. Entonces, si sabe lo que está haciendo, puede usar 39 caracteres, pero si Sólo quiero configurar y olvidarlo, usar 45).

Answer 19

 $_SERVER[''REMOTE_ADDR''];

prueba este

Answer 20

$_SERVER[''REMOTE_ADDR''];

Ejemplo:

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

Answer 21

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

Answer 22

echo $_SERVER[''REMOTE_ADDR''];

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

Answer 23

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