Quel est le moyen le plus précis de récupérer l'adresse IP correcte d'un utilisateur en PHP?
https://stackoverflow.com/questions/1634782
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations 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( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_CLIENT_IP']) && $this->validate_ip( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_CLIENT_IP']))
return Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_CLIENT_IP'];
// Check for IPs passing through proxies
if (!empty( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_FORWARDED_FOR'])) {
// Check if multiple IP addresses exist in var
$iplist = explode(',', Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip) {
if ($this->validate_ip($ip))
return $ip;
}
}
}
if (!empty( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_FORWARDED']) && $this->validate_ip( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_FORWARDED']))
return Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_FORWARDED'];
if (!empty( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_CLUSTER_CLIENT_IP']) && $this->validate_ip( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_CLUSTER_CLIENT_IP']))
return Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_X_CLUSTER_CLIENT_IP'];
if (!empty( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_FORWARDED_FOR']) && $this->validate_ip( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_FORWARDED_FOR']))
return Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_FORWARDED_FOR'];
if (!empty( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_FORWARDED']) && $this->validate_ip( Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_FORWARDED']))
return Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
SERVER['HTTP_FORWARDED'];
// Return unreliable IP address since all else failed
return Je sais qu'il existe une pléthore d'en-têtes de variables $ _ SERVER pour la récupération d'adresse IP. Je me demandais s’il existait un consensus général sur la meilleure façon de récupérer la véritable adresse IP d’un utilisateur (sachant qu'aucune méthode n’était parfaite) à l’aide desdites variables?
J’ai passé un certain temps à essayer de trouver une solution détaillée et j’ai créé le code suivant, basé sur un certain nombre de sources. J'adorerais que quelqu'un puisse, s'il vous plaît, percer des trous dans la réponse ou faire la lumière sur quelque chose de peut-être plus précis.
l'édition inclut les optimisations de @Alix
<*>
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière 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;
}
Paroles d'avertissement (mise à jour)
REMOTE_ADDR représente toujours la source la plus fiable d'une adresse IP. Les autres variables $ _ SERVER mentionnées ici peuvent être usurpées par un client distant très facilement. Le but de cette solution est de tenter de déterminer l'adresse IP d'un client assis derrière un proxy. Pour vos besoins généraux, vous pouvez envisager d’utiliser cette option en combinaison avec l’adresse IP renvoyée directement par $ _ SERVER ['REMOTE_ADDR'] et en stockant les deux.
Pour 99,9% des utilisateurs, cette solution répondra parfaitement à vos besoins. Elle ne vous protégera pas des 0,1% d'utilisateurs malveillants qui cherchent à exploiter votre système en injectant leurs propres en-têtes de requête. Si vous comptez sur des adresses IP pour des tâches critiques, utilisez REMOTE_ADDR et ne vous occupez pas de ceux qui se trouvent derrière un proxy.
La solution
Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
// check for IPs passing through proxies
if (!empty( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
// check for IPs passing through proxies
if (!empty( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
// check for IPs passing through proxies
if (!empty( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
// check if multiple ips exist in var
if (strpos( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false)
{
$iplist = explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
else
{
if ($this->validate_ip( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
return Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR'];
}
}
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
$iplist = explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
// check for IPs passing through proxies
if (!empty( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
// check if multiple ips exist in var
if (strpos( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false)
{
$iplist = explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
else
{
if ($this->validate_ip( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
return Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR'];
}
}
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
{
// check if multiple ips exist in var
if (strpos( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false)
{
$iplist = explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']);
foreach ($iplist as $ip)
{
if ($this->validate_ip($ip))
return $ip;
}
}
else
{
if ($this->validate_ip( Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR']))
return Voici un moyen plus simple et plus précis d'obtenir l'adresse 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, Voici un moyen plus simple et plus précis d'obtenir l'adresse 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;
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER['HTTP_X_FORWARDED_FOR'];
}
}
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses IPv6.
SERVER) === true){
foreach (explode(',', Voici un moyen plus simple et plus précis d'obtenir l'adresse IP:
<*>
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
<*>
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
<*>
À ceci:
<*>
Vous pouvez également vouloir valider les adresses 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;
}
}
}
}
}
J'espère que ça aide!
Votre code semble déjà assez complet, je ne vois aucun bogue possible (hormis les mises en garde IP habituelles), je changerais la fonction validate_ip () en fonction de l'extension de filtre. bien que:
Votre extrait HTTP_X_FORWARDED_FOR peut également être simplifié:
À ceci:
<*>Vous pouvez également vouloir valider les adresses IPv6.
Autres conseils
Même dans ce cas toutefois, l'obtention de la véritable adresse IP d'un utilisateur sera peu fiable. Tout ce qu’ils doivent faire, c’est utiliser un serveur proxy anonyme (qui ne respecte pas les en-têtes de http_x_forwarded_for, http_forwarded, etc.) et vous obtenez uniquement l’adresse IP de leur serveur proxy.
Vous pouvez alors voir s’il existe une liste d’adresses IP de serveurs proxy anonymes, mais il n’ya aucun moyen de s’assurer qu’elles sont exactes à 100% également et le mieux qu’elles fassent est de vous dire que c’est un Serveur proxy. Et si quelqu'un est intelligent, il peut usurper les en-têtes pour les transferts HTTP.
Disons que je n'aime pas le collège local. Je découvre les adresses IP qu'ils ont enregistrées et je fais bannir leur adresse IP sur votre site en faisant de mauvaises choses, car je me rends compte que vous respectez les transferts HTTP. La liste est sans fin.
Ensuite, comme vous l’avez deviné, il existe des adresses IP internes telles que le réseau du collège que j’ai déjà mentionné. Beaucoup utilisent un format 10.x.x.x. Donc, tout ce que vous savez, c'est qu'il a été transféré pour un réseau partagé.
Dans ce cas, je ne commencerai pas beaucoup, mais les adresses IP dynamiques sont désormais la voie du haut débit. Alors. Même si vous obtenez une adresse IP d’utilisateur, attendez-vous à ce qu’elle change d’ici 2 à 3 mois, au plus longtemps.
Nous utilisons:
/**
* Get the customer's IP address.
*
* @return string
*/
public function getIpAddress() {
if (!empty( Nous utilisons:
<*>
L’explosion sur HTTP_X_FORWARDED_FOR est due à des problèmes étranges lors de la détection d’adresses IP lors de la Squid a été utilisé.
SERVER['HTTP_CLIENT_IP'])) {
return Nous utilisons:
<*>
L’explosion sur HTTP_X_FORWARDED_FOR est due à des problèmes étranges lors de la détection d’adresses IP lors de la Squid a été utilisé.
SERVER['HTTP_CLIENT_IP'];
} else if (!empty( Nous utilisons:
<*>
L’explosion sur HTTP_X_FORWARDED_FOR est due à des problèmes étranges lors de la détection d’adresses IP lors de la Squid a été utilisé.
SERVER['HTTP_X_FORWARDED_FOR'])) {
$ips = explode(',', Nous utilisons:
<*>
L’explosion sur HTTP_X_FORWARDED_FOR est due à des problèmes étranges lors de la détection d’adresses IP lors de la Squid a été utilisé.
SERVER['HTTP_X_FORWARDED_FOR']);
return trim($ips[count($ips) - 1]);
} else {
return Nous utilisons:
<*>
L’explosion sur HTTP_X_FORWARDED_FOR est due à des problèmes étranges lors de la détection d’adresses IP lors de la Squid a été utilisé.
SERVER['REMOTE_ADDR'];
}
}
L’explosion sur HTTP_X_FORWARDED_FOR est due à des problèmes étranges lors de la détection d’adresses IP lors de la Squid a été utilisé.
Ma réponse est fondamentalement une version perfectionnée, entièrement validée et entièrement emballée de la réponse de @ AlixAxel:
<?php
/* Get the 'best known' client IP. */
if (!function_exists('getClientIP'))
{
function getClientIP()
{
if (isset( Ma réponse est fondamentalement une version perfectionnée, entièrement validée et entièrement emballée de la réponse de @ AlixAxel:
<*>
Modifications:
-
Cela simplifie le nom de la fonction (avec le style de formatage 'camelCase').
-
Cela inclut une vérification pour vous assurer que la fonction n'est pas déjà déclarée dans une autre partie de votre code.
-
Il prend en compte la compatibilité 'CloudFlare'.
-
Il initialise plusieurs "" IP-related" " les noms de variables à la valeur renvoyée, de la fonction 'getClientIP'.
-
Cela garantit que si la fonction ne renvoie pas une adresse IP valide, toutes les variables sont définies sur une chaîne vide au lieu de null .
-
Ce n’est que (45) lignes de code.
SERVER["HTTP_CF_CONNECTING_IP"]))
{
Ma réponse est fondamentalement une version perfectionnée, entièrement validée et entièrement emballée de la réponse de @ AlixAxel:
<*>
Modifications:
-
Cela simplifie le nom de la fonction (avec le style de formatage 'camelCase').
-
Cela inclut une vérification pour vous assurer que la fonction n'est pas déjà déclarée dans une autre partie de votre code.
-
Il prend en compte la compatibilité 'CloudFlare'.
-
Il initialise plusieurs "" IP-related" " les noms de variables à la valeur renvoyée, de la fonction 'getClientIP'.
-
Cela garantit que si la fonction ne renvoie pas une adresse IP valide, toutes les variables sont définies sur une chaîne vide au lieu de null .
-
Ce n’est que (45) lignes de code.
SERVER['REMOTE_ADDR'] = Ma réponse est fondamentalement une version perfectionnée, entièrement validée et entièrement emballée de la réponse de @ AlixAxel:
<*>
Modifications:
-
Cela simplifie le nom de la fonction (avec le style de formatage 'camelCase').
-
Cela inclut une vérification pour vous assurer que la fonction n'est pas déjà déclarée dans une autre partie de votre code.
-
Il prend en compte la compatibilité 'CloudFlare'.
-
Il initialise plusieurs "" IP-related" " les noms de variables à la valeur renvoyée, de la fonction 'getClientIP'.
-
Cela garantit que si la fonction ne renvoie pas une adresse IP valide, toutes les variables sont définies sur une chaîne vide au lieu de null .
-
Ce n’est que (45) lignes de code.
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, Ma réponse est fondamentalement une version perfectionnée, entièrement validée et entièrement emballée de la réponse de @ AlixAxel:
<*>
Modifications:
-
Cela simplifie le nom de la fonction (avec le style de formatage 'camelCase').
-
Cela inclut une vérification pour vous assurer que la fonction n'est pas déjà déclarée dans une autre partie de votre code.
-
Il prend en compte la compatibilité 'CloudFlare'.
-
Il initialise plusieurs "" IP-related" " les noms de variables à la valeur renvoyée, de la fonction 'getClientIP'.
-
Cela garantit que si la fonction ne renvoie pas une adresse IP valide, toutes les variables sont définies sur une chaîne vide au lieu de null .
-
Ce n’est que (45) lignes de code.
SERVER))
{
foreach (explode(',', Ma réponse est fondamentalement une version perfectionnée, entièrement validée et entièrement emballée de la réponse de @ AlixAxel:
<*>
Modifications:
-
Cela simplifie le nom de la fonction (avec le style de formatage 'camelCase').
-
Cela inclut une vérification pour vous assurer que la fonction n'est pas déjà déclarée dans une autre partie de votre code.
-
Il prend en compte la compatibilité 'CloudFlare'.
-
Il initialise plusieurs "" IP-related" " les noms de variables à la valeur renvoyée, de la fonction 'getClientIP'.
-
Cela garantit que si la fonction ne renvoie pas une adresse IP valide, toutes les variables sont définies sur une chaîne vide au lieu de null .
-
Ce n’est que (45) lignes de code.
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 = '';
};
?>
Modifications:
-
Cela simplifie le nom de la fonction (avec le style de formatage 'camelCase').
-
Cela inclut une vérification pour vous assurer que la fonction n'est pas déjà déclarée dans une autre partie de votre code.
-
Il prend en compte la compatibilité 'CloudFlare'.
-
Il initialise plusieurs "" IP-related" " les noms de variables à la valeur renvoyée, de la fonction 'getClientIP'.
-
Cela garantit que si la fonction ne renvoie pas une adresse IP valide, toutes les variables sont définies sur une chaîne vide au lieu de
null. -
Ce n’est que (45) lignes de code.
La plus grande question est de savoir dans quel but?
Votre code est presque aussi complet qu'il pourrait l'être - mais je vois que si vous repérez ce qui ressemble à un en-tête ajouté au proxy, vous utilisez cet INSTEAD de CLIENT_IP, mais si vous souhaitez que ces informations soient utilisées à des fins d'audit, soyez averti - il est très facile de faire semblant.
Évidemment, vous ne devriez jamais utiliser d’adresses IP pour aucune sorte d’authentification - même celles-ci peuvent être usurpées.
Vous pouvez obtenir une meilleure mesure de l’adresse IP du client en déplaçant un applet flash ou java qui se connecte au serveur via un port non http (qui révélerait donc des proxys transparents ou des cas où les en-têtes injectés false - mais gardez à l'esprit que, lorsque le client peut SEULEMENT se connecter via un proxy Web ou que le port sortant est bloqué, il n'y aura pas de connexion à partir de l'applet.
C.
Juste une version VB.NET de la réponse:
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
Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
// proxybuster - attempts to un-hide originating IP if [reverse]proxy provides methods to do so
$enableProxyBust = true;
if (($enableProxyBust == true) && (isset( Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
function fooNow() {
global $ip, $ipProxy, $ipProxy_label;
// begin this actions such as log, error, query, or report
}
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['REMOTE_ADDR'])) && (isset( Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['HTTP_X_FORWARDED_FOR'])) && (!empty( Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['HTTP_X_FORWARDED_FOR']))) {
$ip = end(array_values(array_filter(explode(',', Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['HTTP_X_FORWARDED_FOR']))));
$ipProxy = Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['REMOTE_ADDR'];
$ipProxy_label = ' behind proxy ';
} elseif (($enableProxyBust == true) && (isset( Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['REMOTE_ADDR']))) {
$ip = Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['REMOTE_ADDR'];
$ipProxy = '';
$ipProxy_label = ' no proxy ';
} elseif (($enableProxyBust == false) && (isset( Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['REMOTE_ADDR']))) {
$ip = Je me rends compte que les réponses ci-dessus sont bien meilleures et plus concises, et qu’il ne s’agit ni d’une fonction ni du script le plus gracieux qui soit. Dans notre cas, nous devions produire à la fois le spoofable x_forwarded_for et le plus fiable remote_addr dans un commutateur simpliste, par exemple. Il fallait permettre aux blancs d'injecter dans d'autres fonctions si-aucune ou si-singulier (plutôt que de simplement renvoyer la fonction préformatée). Il avait besoin d'un " on ou off " var avec une ou plusieurs étiquettes personnalisées par commutateur pour les paramètres de plate-forme. Il fallait également trouver un moyen de rendre dynamique $ ip en fonction de la demande, de manière à prendre la forme de forwarded_for.
De plus, je n'ai vu personne adresser isset () vs! empty () - il est possible de ne rien entrer pour x_forwarded_for tout en déclenchant la vérité isset (), ce qui entraîne une var vierge, un moyen de se déplacer consiste à utiliser & amp; & amp; et combinez les deux comme conditions. N'oubliez pas que vous pouvez usurper des mots tels que "PWNED". comme x_forwarded_for alors assurez-vous de stériliser une syntaxe ip réelle si votre sortie est protégée ou stockée dans une base de données.
Vous pouvez également tester avec Google Translate si vous avez besoin d'un proxy multiple pour afficher le tableau dans x_forwarder_for. Si vous souhaitez tester des en-têtes pour des tests d'usurpation, consultez cette En-tête de client Chrome . une extension. Cela utilisera par défaut uniquement remote_addr standard derrière un proxy.
Je ne connais pas les cas où remote_addr pourrait être vide, mais il existe une solution de secours au cas où.
<*>
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>
Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
SERVER['REMOTE_ADDR'];
$ipProxy = '';
$ipProxy_label = '';
} else {
$ip = '';
$ipProxy = '';
$ipProxy_label = '';
}
Pour rendre ces dynamiques dynamiques à utiliser dans une ou plusieurs fonctions ou dans une requête / écho / vue ci-dessous, par exemple, pour la génération de rapports d’erreurs ou de rapports d’erreurs, utilisez des paramètres globaux ou simplement des échos où vous le souhaitez sans créer une tonne d’autres conditions ou statiques. fonctions de sortie de schéma.
<*>Merci pour toutes vos bonnes pensées. Faites-moi savoir si cela pourrait être mieux, encore un peu nouveau à ces en-têtes:)
J'ai créé cette fonction qui ne renvoie pas simplement l'adresse IP, mais un tableau contenant des informations 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;
}
Voici la fonction:
/**
* 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' => J'ai créé cette fonction qui ne renvoie pas simplement l'adresse IP, mais un tableau contenant des informations 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;
}
Voici la fonction:
<*>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, J'ai créé cette fonction qui ne renvoie pas simplement l'adresse IP, mais un tableau contenant des informations 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;
}
Voici la fonction:
<*>SERVER ) === true ) {
foreach ( explode( ',', J'ai créé cette fonction qui ne renvoie pas simplement l'adresse IP, mais un tableau contenant des informations 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;
}
Voici la fonction:
<*>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;
}
Comme quelqu'un l'a dit précédemment, la clé ici est la raison pour laquelle vous souhaitez stocker les ips de l'utilisateur.
Je vais donner un exemple tiré d’un système d’enregistrement sur lequel je travaille et bien sûr la solution, rien que pour contribuer à cette vieille discussion qui revient fréquemment dans mes recherches.
De nombreuses bibliothèques d'enregistrement php utilisent ip pour limiter / verrouiller les tentatives infructueuses basées sur l'ip de l'utilisateur. Considérez ce tableau:
-- 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
...
Ensuite, lorsqu'un utilisateur essaie de se connecter ou d'utiliser un service comme une réinitialisation de mot de passe, une fonction est appelée au début:
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";
}
Dites, par exemple, $ this- > jeton- > get ('tentatives_auavant_ban') === 10 et 2 utilisateurs obtiennent les mêmes ips que dans les codes précédents les en-têtes peuvent être usurpés , puis après 5 tentatives, chaque est banni !
Pire encore, si tous proviennent du même proxy, seuls les 10 premiers utilisateurs seront connectés et tout le reste sera banni!
Il est essentiel de disposer d'un index unique sur la tentative de la table et de l'obtenir à partir d'une combinaison telle que:
`ip` varchar(39) NOT NULL,
`jwt_load varchar(100) NOT NULL
où jwt_load provient d'un cookie http qui suit la technologie jeton Web Json , où nous stockons uniquement la charge chiffrée qui devrait contenir une valeur arbitraire / unique pour chaque utilisateur.
Bien entendu, la demande doit être modifiée pour: & SELECT; compte (*) FROM {$ this- > token- > get ('table_attempts')} WHERE ip =? AND jwt_load =? & Quot; et la classe doit également lancer un private $ jwt .
Je me demande si vous devriez peut-être parcourir le HTTP_X_FORWARDED_FOR éclaté dans l'ordre inverse, car je sais par expérience que l'adresse IP de l'utilisateur se termine à la fin de la liste séparée par des virgules, donc à partir du début de l'en-tête, vous obtiendrez probablement l'adresse IP de l'un des mandataires renvoyés, ce qui pourrait éventuellement permettre le détournement de session, car de nombreux utilisateurs peuvent passer par ce proxy.
Merci pour cela, très utile.
Cela aiderait cependant si le code était syntaxiquement correct. Comme il y a un nombre trop important autour de la ligne 20. Ce qui, j'en ai bien peur, signifie que personne ne l'a réellement essayé.
Je peux être fou, mais après l'avoir essayé sur quelques adresses valides et non valides, la seule version de validate_ip () qui a fonctionné était la suivante:
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;
}
Voici une version modifiée si vous utilisez les services de couche de mise en cache de CloudFlare
.function getIP()
{
$fields = array('HTTP_X_FORWARDED_FOR',
'REMOTE_ADDR',
'HTTP_CF_CONNECTING_IP',
'HTTP_X_CLUSTER_CLIENT_IP');
foreach($fields as $f)
{
$tries = Voici une version modifiée si vous utilisez les services de couche de mise en cache de CloudFlare
.
<*>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;
}
Juste une autre façon propre:
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( Juste une autre façon propre:
<*>SERVER['HTTP_CLIENT_IP']) ?:
@$this->validateIp( Juste une autre façon propre:
<*>SERVER['HTTP_X_FORWARDED_FOR']) ?:
@$this->validateIp( Juste une autre façon propre:
<*>SERVER['HTTP_X_FORWARDED']) ?:
@$this->validateIp( Juste une autre façon propre:
<*>SERVER['HTTP_FORWARDED_FOR']) ?:
@$this->validateIp( Juste une autre façon propre:
<*>SERVER['HTTP_FORWARDED']) ?:
@$this->validateIp( Juste une autre façon propre:
<*>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);
}
