¿Cuál es la forma más precisa de recuperar la dirección IP correcta de un usuario en PHP?
https://stackoverflow.com/questions/1634782
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
/**
* Retrieves the best guess of the client's actual IP address.
* Takes into account numerous HTTP proxy headers due to variations
* in how different ISPs handle IP addresses in headers between hops.
*/
public function get_ip_address() {
// Check for shared internet/ISP IP
if (!empty( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_CLIENT_IP']) && $this->validate_ip( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_CLIENT_IP']))
return Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_CLIENT_IP'];
// Check for IPs passing through proxies
if (!empty( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_FORWARDED_FOR'])) {
// Check if multiple IP addresses exist in var
$iplist = explode(',', Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip) {
if ($this->validate_ip($ip))
return $ip;
}
}
}
if (!empty( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_FORWARDED']) && $this->validate_ip( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_FORWARDED']))
return Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_FORWARDED'];
if (!empty( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_CLUSTER_CLIENT_IP']) && $this->validate_ip( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_CLUSTER_CLIENT_IP']))
return Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_X_CLUSTER_CLIENT_IP'];
if (!empty( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_FORWARDED_FOR']) && $this->validate_ip( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_FORWARDED_FOR']))
return Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_FORWARDED_FOR'];
if (!empty( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_FORWARDED']) && $this->validate_ip( Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_FORWARDED']))
return Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['HTTP_FORWARDED'];
// Return unreliable IP address since all else failed
return Sé que hay una gran cantidad de encabezados de variables $ _SERVER disponibles para la recuperación de direcciones IP. Me preguntaba si existe un consenso general sobre cómo recuperar con mayor precisión la dirección IP real de un usuario (sabiendo que ningún método es perfecto) utilizando dichas variables.
Pasé un tiempo tratando de encontrar una solución en profundidad y se me ocurrió el siguiente código basado en varias fuentes. Me encantaría que alguien pudiera hacer agujeros en la respuesta o arrojar algo de luz sobre algo tal vez más preciso.
edit incluye optimizaciones de @Alix
<*>
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
SERVER['REMOTE_ADDR'];
}
/**
* Ensures an IP address is both a valid IP address and does not fall within
* a private network range.
*
* @access public
* @param string $ip
*/
public function validate_ip($ip) {
if (filter_var($ip, FILTER_VALIDATE_IP,
FILTER_FLAG_IPV4 |
FILTER_FLAG_IPV6 |
FILTER_FLAG_NO_PRIV_RANGE |
FILTER_FLAG_NO_RES_RANGE) === false)
return false;
self::$ip = $ip;
return true;
}
Palabras de advertencia (actualización)
REMOTE_ADDR todavía representa la fuente más confiable de una dirección IP. Las otras variables $ _SERVER mencionadas aquí pueden ser suplantadas por un cliente remoto muy fácilmente. El propósito de esta solución es intentar determinar la dirección IP de un cliente sentado detrás de un proxy. Para sus propósitos generales, puede considerar usar esto en combinación con la dirección IP devuelta directamente desde $ _SERVER ['REMOTE_ADDR'] y almacenar ambos.
Para el 99.9% de los usuarios, esta solución se adaptará perfectamente a sus necesidades. No lo protegerá del 0.1% de los usuarios maliciosos que buscan abusar de su sistema al inyectar sus propios encabezados de solicitud. Si confía en las direcciones IP para algo de misión crítica, recurra a REMOTE_ADDR y no se moleste en atender a quienes están detrás de un proxy.
Solución
Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
// check for IPs passing through proxies
if (!empty( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
// check for IPs passing through proxies
if (!empty( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
// check for IPs passing through proxies
if (!empty( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
// check if multiple ips exist in var
if (strpos( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false)
{
$iplist = explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
else
{
if ($this->validate_ip( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
return Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR'];
}
}
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
$iplist = explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
// check for IPs passing through proxies
if (!empty( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
// check if multiple ips exist in var
if (strpos( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false)
{
$iplist = explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
else
{
if ($this->validate_ip( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
return Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR'];
}
}
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
// check if multiple ips exist in var
if (strpos( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false)
{
$iplist = explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
else
{
if ($this->validate_ip( Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
return Aquí hay una forma más corta y limpia de obtener la dirección IP:
function get_ip_address(){
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, Aquí hay una forma más corta y limpia de obtener la dirección IP:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false)
{
return false;
}
self::$ip = sprintf('%u', ip2long($ip)); // you seem to want this
return true;
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER['HTTP_X_FORWARDED_FOR'];
}
}
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER) === true){
foreach (explode(',', Aquí hay una forma más corta y limpia de obtener la dirección IP:
<*>
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
<*>
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
<*>
A esto:
<*>
También es posible que desee validar las direcciones IPv6.
SERVER[$key]) as $ip){
$ip = trim($ip); // just to be safe
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false){
return $ip;
}
}
}
}
}
¡Espero que ayude!
Su código parece estar bastante completo ya, no puedo ver ningún posible error en él (aparte de las advertencias de IP habituales), cambiaría la función validate_ip () para confiar en la extensión del filtro aunque:
También su fragmento HTTP_X_FORWARDED_FOR puede simplificarse de esta manera:
A esto:
<*>También es posible que desee validar las direcciones IPv6.
Otros consejos
Sin embargo, incluso entonces, obtener la dirección IP real de un usuario no será confiable. Todo lo que necesitan hacer es usar un servidor proxy anónimo (uno que no respete los encabezados de http_x_forwards_for, http_forwards, etc.) y todo lo que obtendrá es la dirección IP de su servidor proxy.
A continuación, puede ver si hay una lista de direcciones IP del servidor proxy que son anónimas, pero no hay forma de asegurarse de que también sea 100% precisa y lo máximo que puede hacer es hacerle saber que es una servidor proxy. Y si alguien es inteligente, puede falsificar encabezados para reenviar HTTP.
Digamos que no me gusta la universidad local. Averiguo qué direcciones IP registraron, y hago que su dirección IP sea prohibida en su sitio haciendo cosas malas, porque creo que honran los reenvíos HTTP. La lista es interminable.
Luego, como adivinó, hay direcciones IP internas como la red universitaria que mencioné anteriormente. Muchos usan un formato 10.x.x.x. Entonces, todo lo que sabría es que se reenvió para una red compartida.
Entonces no comenzaré mucho en eso, pero las direcciones IP dinámicas ya no son la banda ancha. Asi que. Incluso si obtiene una dirección IP de usuario, espere que cambie en 2 a 3 meses, como máximo.
Usamos:
/**
* Get the customer's IP address.
*
* @return string
*/
public function getIpAddress() {
if (!empty( Usamos:
<*>
La explosión en HTTP_X_FORWARDED_FOR se debe a problemas extraños que tuvimos al detectar direcciones IP cuando Squid se utilizó.
SERVER['HTTP_CLIENT_IP'])) {
return Usamos:
<*>
La explosión en HTTP_X_FORWARDED_FOR se debe a problemas extraños que tuvimos al detectar direcciones IP cuando Squid se utilizó.
SERVER['HTTP_CLIENT_IP'];
} else if (!empty( Usamos:
<*>
La explosión en HTTP_X_FORWARDED_FOR se debe a problemas extraños que tuvimos al detectar direcciones IP cuando Squid se utilizó.
SERVER['HTTP_X_FORWARDED_FOR'])) {
$ips = explode(',', Usamos:
<*>
La explosión en HTTP_X_FORWARDED_FOR se debe a problemas extraños que tuvimos al detectar direcciones IP cuando Squid se utilizó.
SERVER['HTTP_X_FORWARDED_FOR']);
return trim($ips[count($ips) - 1]);
} else {
return Usamos:
<*>
La explosión en HTTP_X_FORWARDED_FOR se debe a problemas extraños que tuvimos al detectar direcciones IP cuando Squid se utilizó.
SERVER['REMOTE_ADDR'];
}
}
La explosión en HTTP_X_FORWARDED_FOR se debe a problemas extraños que tuvimos al detectar direcciones IP cuando Squid se utilizó.
Mi respuesta es básicamente una versión pulida, totalmente validada y completamente empaquetada de la respuesta de @ AlixAxel:
<?php
/* Get the 'best known' client IP. */
if (!function_exists('getClientIP'))
{
function getClientIP()
{
if (isset( Mi respuesta es básicamente una versión pulida, totalmente validada y completamente empaquetada de la respuesta de @ AlixAxel:
<*>
Cambios:
-
Simplifica el nombre de la función (con el estilo de formato 'camelCase').
-
Incluye una verificación para asegurarse de que la función no esté declarada en otra parte de su código.
-
Tiene en cuenta la compatibilidad con 'CloudFlare'.
-
Inicializa múltiples "relacionados con IP" nombres de variables para el valor devuelto, de la función 'getClientIP'.
-
Asegura que si la función no devuelve una dirección IP válida, todas las variables se configuran en una cadena vacía, en lugar de null.
-
Son solo (45) líneas de código.
SERVER["HTTP_CF_CONNECTING_IP"]))
{
Mi respuesta es básicamente una versión pulida, totalmente validada y completamente empaquetada de la respuesta de @ AlixAxel:
<*>
Cambios:
-
Simplifica el nombre de la función (con el estilo de formato 'camelCase').
-
Incluye una verificación para asegurarse de que la función no esté declarada en otra parte de su código.
-
Tiene en cuenta la compatibilidad con 'CloudFlare'.
-
Inicializa múltiples "relacionados con IP" nombres de variables para el valor devuelto, de la función 'getClientIP'.
-
Asegura que si la función no devuelve una dirección IP válida, todas las variables se configuran en una cadena vacía, en lugar de null.
-
Son solo (45) líneas de código.
SERVER['REMOTE_ADDR'] = Mi respuesta es básicamente una versión pulida, totalmente validada y completamente empaquetada de la respuesta de @ AlixAxel:
<*>
Cambios:
-
Simplifica el nombre de la función (con el estilo de formato 'camelCase').
-
Incluye una verificación para asegurarse de que la función no esté declarada en otra parte de su código.
-
Tiene en cuenta la compatibilidad con 'CloudFlare'.
-
Inicializa múltiples "relacionados con IP" nombres de variables para el valor devuelto, de la función 'getClientIP'.
-
Asegura que si la función no devuelve una dirección IP válida, todas las variables se configuran en una cadena vacía, en lugar de null.
-
Son solo (45) líneas de código.
SERVER["HTTP_CF_CONNECTING_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, Mi respuesta es básicamente una versión pulida, totalmente validada y completamente empaquetada de la respuesta de @ AlixAxel:
<*>
Cambios:
-
Simplifica el nombre de la función (con el estilo de formato 'camelCase').
-
Incluye una verificación para asegurarse de que la función no esté declarada en otra parte de su código.
-
Tiene en cuenta la compatibilidad con 'CloudFlare'.
-
Inicializa múltiples "relacionados con IP" nombres de variables para el valor devuelto, de la función 'getClientIP'.
-
Asegura que si la función no devuelve una dirección IP válida, todas las variables se configuran en una cadena vacía, en lugar de null.
-
Son solo (45) líneas de código.
SERVER))
{
foreach (explode(',', Mi respuesta es básicamente una versión pulida, totalmente validada y completamente empaquetada de la respuesta de @ AlixAxel:
<*>
Cambios:
-
Simplifica el nombre de la función (con el estilo de formato 'camelCase').
-
Incluye una verificación para asegurarse de que la función no esté declarada en otra parte de su código.
-
Tiene en cuenta la compatibilidad con 'CloudFlare'.
-
Inicializa múltiples "relacionados con IP" nombres de variables para el valor devuelto, de la función 'getClientIP'.
-
Asegura que si la función no devuelve una dirección IP válida, todas las variables se configuran en una cadena vacía, en lugar de null.
-
Son solo (45) líneas de código.
SERVER[$key]) as $ip)
{
$ip = trim($ip);
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false)
{
return $ip;
};
};
};
};
return false;
};
};
$best_known_ip = getClientIP();
if(!empty($best_known_ip))
{
$ip = $clients_ip = $client_ip = $client_IP = $best_known_ip;
}
else
{
$ip = $clients_ip = $client_ip = $client_IP = $best_known_ip = '';
};
?>
Cambios:
-
Simplifica el nombre de la función (con el estilo de formato 'camelCase').
-
Incluye una verificación para asegurarse de que la función no esté declarada en otra parte de su código.
-
Tiene en cuenta la compatibilidad con 'CloudFlare'.
-
Inicializa múltiples "relacionados con IP" nombres de variables para el valor devuelto, de la función 'getClientIP'.
-
Asegura que si la función no devuelve una dirección IP válida, todas las variables se configuran en una cadena vacía, en lugar de
null. -
Son solo (45) líneas de código.
La pregunta más importante es ¿para qué?
Su código es casi tan completo como podría ser, pero veo que si ve lo que parece un encabezado agregado proxy, usa ese INSTEAD del CLIENT_IP, sin embargo, si desea esta información para fines de auditoría, se le advierte: es muy fácil de falsificar.
Ciertamente, nunca debe usar direcciones IP para ningún tipo de autenticación, incluso estas pueden ser falsificadas.
Puede obtener una mejor medición de la dirección IP del cliente al extraer un applet flash o java que se conecta de nuevo al servidor a través de un puerto no http (que por lo tanto revelaría proxies transparentes o casos donde los encabezados inyectados por proxy son falso, pero tenga en cuenta que, donde el cliente SOLO puede conectarse a través de un proxy web o el puerto de salida está bloqueado, no habrá conexión desde el applet.
C.
Solo una VB.NET versión de la respuesta:
Private Function GetRequestIpAddress() As IPAddress
Dim serverVariables = HttpContext.Current.Request.ServerVariables
Dim headersKeysToCheck = {"HTTP_CLIENT_IP", _
"HTTP_X_FORWARDED_FOR", _
"HTTP_X_FORWARDED", _
"HTTP_X_CLUSTER_CLIENT_IP", _
"HTTP_FORWARDED_FOR", _
"HTTP_FORWARDED", _
"REMOTE_ADDR"}
For Each thisHeaderKey In headersKeysToCheck
Dim thisValue = serverVariables.Item(thisHeaderKey)
If thisValue IsNot Nothing Then
Dim validAddress As IPAddress = Nothing
If IPAddress.TryParse(thisValue, validAddress) Then
Return validAddress
End If
End If
Next
Return Nothing
End Function
Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
// proxybuster - attempts to un-hide originating IP if [reverse]proxy provides methods to do so
$enableProxyBust = true;
if (($enableProxyBust == true) && (isset( Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
function fooNow() {
global $ip, $ipProxy, $ipProxy_label;
// begin this actions such as log, error, query, or report
}
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['REMOTE_ADDR'])) && (isset( Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['HTTP_X_FORWARDED_FOR'])) && (!empty( Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['HTTP_X_FORWARDED_FOR']))) {
$ip = end(array_values(array_filter(explode(',', Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['HTTP_X_FORWARDED_FOR']))));
$ipProxy = Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['REMOTE_ADDR'];
$ipProxy_label = ' behind proxy ';
} elseif (($enableProxyBust == true) && (isset( Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['REMOTE_ADDR']))) {
$ip = Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['REMOTE_ADDR'];
$ipProxy = '';
$ipProxy_label = ' no proxy ';
} elseif (($enableProxyBust == false) && (isset( Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['REMOTE_ADDR']))) {
$ip = Me doy cuenta de que hay respuestas mucho mejores y más concisas arriba, y esta no es una función ni el guión más elegante. En nuestro caso, necesitábamos generar tanto el spoofable x_forwards_for como el remote_addr más confiable en un conmutador simplista por decir. Necesitaba dejar espacios en blanco para inyectar en otras funciones if-none o if-singular (en lugar de simplemente devolver la función preformateada). Necesitaba un "encendido o apagado" var con una etiqueta o etiquetas personalizadas por interruptor para la configuración de la plataforma. También necesitaba una forma de que $ ip sea dinámico dependiendo de la solicitud para que tome la forma de forwards_for.
Tampoco vi a nadie direccionar isset () vs! empty () - es posible ingresar nada para x_fordered_for todavía desencadenar isset () verdad resultando en var en blanco, una forma de moverse es usar & amp; & amp; y combinar ambos como condiciones. Tenga en cuenta que puede suplantar palabras como "PWNED" como x_forwards_for, así que asegúrese de esterilizar a una sintaxis IP real si su salida está en algún lugar protegido o en la base de datos.
Además, puedes probar usando el traductor de Google si necesitas un proxy múltiple para ver la matriz en x_forwarder_for. Si desea probar encabezados falsos, consulte esto Spoof de encabezado de cliente de Chrome extensión. De forma predeterminada, solo se utilizará remote_addr estándar mientras se encuentre detrás de un proxy proxy.
No sé ningún caso en el que remote_addr podría estar vacío, pero está allí como reserva por si acaso.
<*>
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>
Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
SERVER['REMOTE_ADDR'];
$ipProxy = '';
$ipProxy_label = '';
} else {
$ip = '';
$ipProxy = '';
$ipProxy_label = '';
}
Para hacer que estas dinámicas se utilicen en las funciones o consultas / eco / vistas a continuación, digamos para informes de errores o generación de registros, use globals o simplemente repítalos en el lugar que desee sin hacer un montón de otras condiciones o estáticas. funciones de salida de esquema.
<*>Gracias por todos tus buenos pensamientos. Avíseme si esto podría ser mejor, todavía un poco nuevo para estos encabezados :)
Se me ocurrió esta función que no solo devuelve la dirección IP sino una matriz con información IP.
// Example usage:
$info = ip_info();
if ( $info->proxy ) {
echo 'Your IP is ' . $info->ip;
} else {
echo 'Your IP is ' . $info->ip . ' and your proxy is ' . $info->proxy_ip;
}
Aquí está la función:
/**
* Retrieves the best guess of the client's actual IP address.
* Takes into account numerous HTTP proxy headers due to variations
* in how different ISPs handle IP addresses in headers between hops.
*
* @since 1.1.3
*
* @return object {
* IP Address details
*
* string $ip The users IP address (might be spoofed, if $proxy is true)
* bool $proxy True, if a proxy was detected
* string $proxy_id The proxy-server IP address
* }
*/
function ip_info() {
$result = (object) array(
'ip' => Se me ocurrió esta función que no solo devuelve la dirección IP sino una matriz con información IP.
// Example usage:
$info = ip_info();
if ( $info->proxy ) {
echo 'Your IP is ' . $info->ip;
} else {
echo 'Your IP is ' . $info->ip . ' and your proxy is ' . $info->proxy_ip;
}
Aquí está la función:
<*>SERVER['REMOTE_ADDR'],
'proxy' => false,
'proxy_ip' => '',
);
/*
* This code tries to bypass a proxy and get the actual IP address of
* the visitor behind the proxy.
* Warning: These values might be spoofed!
*/
$ip_fields = array(
'HTTP_CLIENT_IP',
'HTTP_X_FORWARDED_FOR',
'HTTP_X_FORWARDED',
'HTTP_X_CLUSTER_CLIENT_IP',
'HTTP_FORWARDED_FOR',
'HTTP_FORWARDED',
'REMOTE_ADDR',
);
foreach ( $ip_fields as $key ) {
if ( array_key_exists( $key, Se me ocurrió esta función que no solo devuelve la dirección IP sino una matriz con información IP.
// Example usage:
$info = ip_info();
if ( $info->proxy ) {
echo 'Your IP is ' . $info->ip;
} else {
echo 'Your IP is ' . $info->ip . ' and your proxy is ' . $info->proxy_ip;
}
Aquí está la función:
<*>SERVER ) === true ) {
foreach ( explode( ',', Se me ocurrió esta función que no solo devuelve la dirección IP sino una matriz con información IP.
// Example usage:
$info = ip_info();
if ( $info->proxy ) {
echo 'Your IP is ' . $info->ip;
} else {
echo 'Your IP is ' . $info->ip . ' and your proxy is ' . $info->proxy_ip;
}
Aquí está la función:
<*>SERVER[$key] ) as $ip ) {
$ip = trim( $ip );
if ( filter_var( $ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE ) !== false ) {
$forwarded = $ip;
break 2;
}
}
}
}
// If we found a different IP address then REMOTE_ADDR then it's a proxy!
if ( $forwarded != $result->ip ) {
$result->proxy = true;
$result->proxy_ip = $result->ip;
$result->ip = $forwarded;
}
return $result;
}
Como alguien dijo anteriormente, la clave aquí es por qué razón desea almacenar los ips del usuario.
Daré un ejemplo de un sistema de registro en el que trabajo y, por supuesto, la solución solo para contribuir algo en esta vieja discusión que aparece con frecuencia en mis búsquedas.
Muchas bibliotecas de registro de php usan ip para limitar / bloquear intentos fallidos en función de la ip del usuario. Considere esta tabla:
-- mysql
DROP TABLE IF EXISTS `attempts`;
CREATE TABLE `attempts` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`ip` varchar(39) NOT NULL, /*<<=====*/
`expiredate` datetime NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- sqlite
...
Luego, cuando un usuario intenta hacer un inicio de sesión o cualquier cosa relacionada con el mantenimiento, como un restablecimiento de contraseña, se llama a una función al inicio:
public function isBlocked() {
/*
* used one of the above methods to capture user's ip!!!
*/
$ip = $this->ip;
// delete attempts from this ip with 'expiredate' in the past
$this->deleteAttempts($ip, false);
$query = $this->dbh->prepare("SELECT count(*) FROM {$this->token->get('table_attempts')} WHERE ip = ?");
$query->execute(array($ip));
$attempts = $query->fetchColumn();
if ($attempts < intval($this->token->get('attempts_before_verify'))) {
return "allow";
}
if ($attempts < intval($this->token->get('attempts_before_ban'))) {
return "captcha";
}
return "block";
}
Digamos, por ejemplo, $ this- > token- > get ('intentos_before_ban') === 10 y 2 usuarios vienen por los mismos ips como es el caso en los códigos anteriores ¡ donde los encabezados pueden ser falsificados , luego de 5 intentos cada ambos están prohibidos !
Peor aún, si todos provienen del mismo proxy, ¡solo se registrarán los primeros 10 usuarios y se prohibirá el resto!
Lo crítico aquí es que necesitamos un índice único en la tabla intentos y podemos obtenerlo de una combinación como:
`ip` varchar(39) NOT NULL,
`jwt_load varchar(100) NOT NULL
donde jwt_load proviene de una cookie http que sigue la tecnología json web token donde almacenamos solo la carga útil cifrada que debería contener un valor arbitrario / único para cada usuario.
Por supuesto, la solicitud debe modificarse a: " SELECT count (*) FROM {$ this- > token- > get ('table_attempts')} WHERE ip =? Y jwt_load =? & Quot; y la clase también debe iniciar un private $ jwt .
Me pregunto si tal vez deberías iterar sobre el explotado HTTP_X_FORWARDED_FOR en orden inverso, ya que mi experiencia ha sido que la dirección IP del usuario termina al final de la lista separada por comas, así que comenzando al comienzo del encabezado, es más probable que obtenga la dirección IP de uno de los proxies devueltos, lo que podría permitir el secuestro de sesión ya que muchos usuarios pueden acceder a través de ese proxy.
Gracias por esto, muy útil.
Sin embargo, sería útil que el código fuera sintácticamente correcto. Tal como está, hay un {demasiados alrededor de la línea 20. Lo que me temo que significa que en realidad nadie lo intentó.
Puedo estar loco, pero después de probarlo en algunas direcciones válidas e inválidas, la única versión de validate_ip () que funcionó fue esta:
public function validate_ip($ip)
{
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE) === false)
return false;
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE) === false)
return false;
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) === false && filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) === false)
return false;
return true;
}
Aquí hay una versión modificada si utiliza CloudFlare Servicios de capa de almacenamiento en caché
function getIP()
{
$fields = array('HTTP_X_FORWARDED_FOR',
'REMOTE_ADDR',
'HTTP_CF_CONNECTING_IP',
'HTTP_X_CLUSTER_CLIENT_IP');
foreach($fields as $f)
{
$tries = Aquí hay una versión modificada si utiliza CloudFlare Servicios de capa de almacenamiento en caché
<*>SERVER[$f];
if (empty($tries))
continue;
$tries = explode(',',$tries);
foreach($tries as $try)
{
$r = filter_var($try,
FILTER_VALIDATE_IP, FILTER_FLAG_IPV4 |
FILTER_FLAG_NO_PRIV_RANGE |
FILTER_FLAG_NO_RES_RANGE);
if ($r !== false)
{
return $try;
}
}
}
return false;
}
Simplemente otra forma limpia:
function validateIp($var_ip){
$ip = trim($var_ip);
return (!empty($ip) &&
$ip != '::1' &&
$ip != '127.0.0.1' &&
filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false)
? $ip : false;
}
function getClientIp() {
$ip = @$this->validateIp( Simplemente otra forma limpia:
<*>SERVER['HTTP_CLIENT_IP']) ?:
@$this->validateIp( Simplemente otra forma limpia:
<*>SERVER['HTTP_X_FORWARDED_FOR']) ?:
@$this->validateIp( Simplemente otra forma limpia:
<*>SERVER['HTTP_X_FORWARDED']) ?:
@$this->validateIp( Simplemente otra forma limpia:
<*>SERVER['HTTP_FORWARDED_FOR']) ?:
@$this->validateIp( Simplemente otra forma limpia:
<*>SERVER['HTTP_FORWARDED']) ?:
@$this->validateIp( Simplemente otra forma limpia:
<*>SERVER['REMOTE_ADDR']) ?:
'LOCAL OR UNKNOWN ACCESS';
return $ip;
}
/**
* Sanitizes IPv4 address according to Ilia Alshanetsky's book
* "php|architect?s Guide to PHP Security", chapter 2, page 67.
*
* @param string $ip An IPv4 address
*/
public static function sanitizeIpAddress($ip = '')
{
if ($ip == '')
{
$rtnStr = '0.0.0.0';
}
else
{
$rtnStr = long2ip(ip2long($ip));
}
return $rtnStr;
}
//---------------------------------------------------
/**
* Returns the sanitized HTTP_X_FORWARDED_FOR server variable.
*
*/
public static function getXForwardedFor()
{
if (isset(<*>SERVER['HTTP_X_FORWARDED_FOR']))
{
$rtnStr = <*>SERVER['HTTP_X_FORWARDED_FOR'];
}
elseif (isset($HTTP_SERVER_VARS['HTTP_X_FORWARDED_FOR']))
{
$rtnStr = $HTTP_SERVER_VARS['HTTP_X_FORWARDED_FOR'];
}
elseif (getenv('HTTP_X_FORWARDED_FOR'))
{
$rtnStr = getenv('HTTP_X_FORWARDED_FOR');
}
else
{
$rtnStr = '';
}
// Sanitize IPv4 address (Ilia Alshanetsky):
if ($rtnStr != '')
{
$rtnStr = explode(', ', $rtnStr);
$rtnStr = self::sanitizeIpAddress($rtnStr[0]);
}
return $rtnStr;
}
//---------------------------------------------------
/**
* Returns the sanitized REMOTE_ADDR server variable.
*
*/
public static function getRemoteAddr()
{
if (isset(<*>SERVER['REMOTE_ADDR']))
{
$rtnStr = <*>SERVER['REMOTE_ADDR'];
}
elseif (isset($HTTP_SERVER_VARS['REMOTE_ADDR']))
{
$rtnStr = $HTTP_SERVER_VARS['REMOTE_ADDR'];
}
elseif (getenv('REMOTE_ADDR'))
{
$rtnStr = getenv('REMOTE_ADDR');
}
else
{
$rtnStr = '';
}
// Sanitize IPv4 address (Ilia Alshanetsky):
if ($rtnStr != '')
{
$rtnStr = explode(', ', $rtnStr);
$rtnStr = self::sanitizeIpAddress($rtnStr[0]);
}
return $rtnStr;
}
//---------------------------------------------------
/**
* Returns the sanitized remote user and proxy IP addresses.
*
*/
public static function getIpAndProxy()
{
$xForwarded = self::getXForwardedFor();
$remoteAddr = self::getRemoteAddr();
if ($xForwarded != '')
{
$ip = $xForwarded;
$proxy = $remoteAddr;
}
else
{
$ip = $remoteAddr;
$proxy = '';
}
return array($ip, $proxy);
}
