Comment obtenir l'adresse IP du client d'un utilisateur dans ASP.NET?

Nous devons Request.UserHostAddressobtenir l'adresse IP dans ASP.NET, mais c'est généralement l'adresse IP du FAI de l'utilisateur, pas exactement l'adresse IP de la machine de l'utilisateur qui, par exemple, a cliqué sur un lien. Comment puis-je obtenir la véritable adresse IP?

Par exemple, dans un profil utilisateur Stack Overflow, c'est: "Dernière activité de compte: il y a 4 heures depuis 86.123.127.8" , mais l'adresse IP de ma machine est un peu différente. Comment Stack Overflow obtient-elle cette adresse?

Dans certains systèmes Web, il existe une vérification d'adresse IP à certaines fins. Par exemple, avec une certaine adresse IP, pour toutes les 24 heures, l'utilisateur ne peut-il avoir que 5 clics sur les liens de téléchargement? Cette adresse IP doit être unique, pas pour un FAI qui a une vaste gamme de clients ou d'utilisateurs Internet.

Ai-je bien compris?

Comme d'autres l'ont dit, vous ne pouvez pas faire ce que vous demandez. Si vous décrivez le problème que vous essayez de résoudre, peut-être que quelqu'un peut vous aider?

Par exemple

• essayez-vous d'identifier de manière unique vos utilisateurs?
• Pourriez-vous utiliser un cookie, ou l'ID de session peut-être à la place de l'adresse IP?

ÉditerL'adresse que vous voyez sur le serveur ne doit pas être l'adresse du FAI, car vous dites que ce serait une énorme plage. L'adresse d'un utilisateur domestique sur large bande sera l'adresse de leur routeur, donc chaque appareil à l'intérieur de la maison apparaîtra à l'extérieur pour être le même, mais le routeur utilise NAT pour s'assurer que le trafic est correctement acheminé vers chaque appareil. Pour les utilisateurs accédant à partir d'un environnement de bureau, l'adresse peut être la même pour tous les utilisateurs. Les sites qui utilisent une adresse IP pour l'ID courent le risque de se tromper - les exemples que vous donnez sont bons et ils échouent souvent. Par exemple, mon bureau est au Royaume-Uni, le point de rupture (où je "semble" être sur Internet) est dans un autre pays où se trouve notre principale installation informatique, donc depuis mon bureau, mon adresse IP ne semble pas être au Royaume-Uni. Pour cette raison, je ne peux pas accéder au contenu Web uniquement au Royaume-Uni, comme le BBC iPlayer). À tout moment, il y aurait des centaines, voire des milliers de personnes dans mon entreprise qui semblent accéder au Web à partir de la même adresse IP.

Lorsque vous écrivez du code serveur, vous ne pouvez jamais être sûr de l’adresse IP à laquelle vous voyez. Certains utilisateurs aiment ça. Certaines personnes utilisent délibérément un proxy ou un VPN pour vous confondre davantage.

Lorsque vous dites que l'adresse de votre machine est différente de l'adresse IP indiquée sur StackOverflow, comment trouvez-vous l'adresse de votre machine? Si vous cherchez simplement à utiliser localement ipconfigou quelque chose comme ça, je m'attendrais à ce que ce soit différent pour les raisons que j'ai décrites ci-dessus. Si vous voulez vérifier ce que pense le monde extérieur, consultez whatismyipaddress.com/ .

Ce lien Wikipédia sur NAT vous fournira quelques informations à ce sujet.

Souvent, vous voudrez connaître l'adresse IP d'une personne visitant votre site Web. Bien qu'ASP.NET ait plusieurs façons de le faire, l'une des meilleures façons que nous avons vues est d'utiliser le "HTTP_X_FORWARDED_FOR" de la collection ServerVariables.

Voici pourquoi...

Parfois, vos visiteurs se trouvent derrière un serveur proxy ou un routeur et la norme Request.UserHostAddresscapture uniquement l'adresse IP du serveur proxy ou du routeur. Dans ce cas, l'adresse IP de l'utilisateur est alors stockée dans la variable serveur ("HTTP_X_FORWARDED_FOR").

Donc, ce que nous voulons faire, c'est d'abord vérifier "HTTP_X_FORWARDED_FOR" et si c'est vide, nous revenons simplement ServerVariables("REMOTE_ADDR").

Bien que cette méthode ne soit pas infaillible, elle peut conduire à de meilleurs résultats. Ci-dessous, le code ASP.NET dans VB.NET, extrait du billet de blog de James Crowley "Gotcha: HTTP_X_FORWARDED_FOR renvoie plusieurs adresses IP"

C #

protected string GetIPAddress()
{
    System.Web.HttpContext context = System.Web.HttpContext.Current; 
    string ipAddress = context.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];

    if (!string.IsNullOrEmpty(ipAddress))
    {
        string[] addresses = ipAddress.Split(',');
        if (addresses.Length != 0)
        {
            return addresses[0];
        }
    }

    return context.Request.ServerVariables["REMOTE_ADDR"];
}

VB.NET

Public Shared Function GetIPAddress() As String
    Dim context As System.Web.HttpContext = System.Web.HttpContext.Current
    Dim sIPAddress As String = context.Request.ServerVariables("HTTP_X_FORWARDED_FOR")
    If String.IsNullOrEmpty(sIPAddress) Then
        Return context.Request.ServerVariables("REMOTE_ADDR")
    Else
        Dim ipArray As String() = sIPAddress.Split(New [Char]() {","c})
        Return ipArray(0)
    End If
End Function

MISE À JOUR: Merci à Bruno Lopes. Si plusieurs adresses IP peuvent venir, vous devez utiliser cette méthode:

    private string GetUserIP()
    {
        string ipList = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];

        if (!string.IsNullOrEmpty(ipList))
        {
            return ipList.Split(',')[0];
        }

        return Request.ServerVariables["REMOTE_ADDR"];
    }

Si est c # voir de cette façon, est très simple

string clientIp = (Request.ServerVariables["HTTP_X_FORWARDED_FOR"] ?? 
                   Request.ServerVariables["REMOTE_ADDR"]).Split(',')[0].Trim();

Que considérez-vous d'autre comme l'adresse IP de l'utilisateur? Si vous voulez l'adresse IP de la carte réseau, je crains qu'il n'y ait aucun moyen possible de le faire dans une application Web. Si votre utilisateur est derrière NAT ou autre, vous ne pouvez pas non plus obtenir l'IP.

Mise à jour : Bien qu'il existe des sites Web qui utilisent IP pour limiter l'utilisateur (comme rapidshare), ils ne fonctionnent pas correctement dans les environnements NAT.

Je pense que je devrais partager mon expérience avec vous tous. Eh bien, je vois que dans certaines situations, REMOTE_ADDR ne vous donnera PAS ce que vous cherchez. Par exemple, si vous avez un équilibreur de charge derrière la scène et si vous essayez d'obtenir l'IP du client, vous aurez des problèmes. Je l'ai vérifié avec mon logiciel de masquage IP et j'ai également vérifié avec mes collègues se trouvant sur différents continents. Voici donc ma solution.

Lorsque je veux connaître l'IP d'un client, j'essaie de sélectionner toutes les preuves possibles afin de pouvoir déterminer si elles sont uniques:

Ici, j'ai trouvé un autre serveur qui pourrait vous aider tous si vous voulez obtenir l'IP exacte du côté client. donc j'utilise: HTTP_X_CLUSTER_CLIENT_IP

HTTP_X_CLUSTER_CLIENT_IP vous obtient toujours l'adresse IP exacte du client. Dans tous les cas, si cela ne vous donne pas la valeur, vous devez alors rechercher HTTP_X_FORWARDED_FOR car c'est le deuxième meilleur candidat pour vous obtenir l'adresse IP du client, puis la variable REMOTE_ADDR qui peut ou non vous renvoyer l'IP, mais pour moi, avoir tout cela trois est ce que je trouve le mieux pour les surveiller.

J'espère que cela aide certains gars.

Vous pouvez utiliser:

System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName()).AddressList.GetValue(0).ToString();

Les adresses IP font partie de la couche Réseau dans la "pile à sept couches". La couche réseau peut faire tout ce qu'elle veut faire avec l'adresse IP. C'est ce qui se passe avec un serveur proxy, NAT, relais ou autre.

La couche Application ne doit en aucun cas dépendre de l'adresse IP. En particulier, une adresse IP n'est pas censée être un identifiant de quelque chose d'autre que l'idenfitier d'une extrémité d'une connexion réseau. Dès qu'une connexion est fermée, vous devez vous attendre à ce que l'adresse IP (du même utilisateur) change.

Jusqu'à présent, toutes les réponses tiennent compte de l'en- tête non normalisé, mais très courant X-Forwarded-For. Il existe un en- Forwardedtête standardisé qui est un peu plus difficile à analyser. Voici quelques exemples:

Forwarded: for="_gazonk"
Forwarded: For="[2001:db8:cafe::17]:4711"
Forwarded: for=192.0.2.60;proto=http;by=203.0.113.43
Forwarded: for=192.0.2.43, for=198.51.100.17

J'ai écrit une classe qui prend en compte ces deux en-têtes lors de la détermination de l'adresse IP d'un client.

using System;
using System.Web;

namespace Util
{
    public static class IP
    {
        public static string GetIPAddress()
        {
            return GetIPAddress(new HttpRequestWrapper(HttpContext.Current.Request));
        }

        internal static string GetIPAddress(HttpRequestBase request)
        {
            // handle standardized 'Forwarded' header
            string forwarded = request.Headers["Forwarded"];
            if (!String.IsNullOrEmpty(forwarded))
            {
                foreach (string segment in forwarded.Split(',')[0].Split(';'))
                {
                    string[] pair = segment.Trim().Split('=');
                    if (pair.Length == 2 && pair[0].Equals("for", StringComparison.OrdinalIgnoreCase))
                    {
                        string ip = pair[1].Trim('"');

                        // IPv6 addresses are always enclosed in square brackets
                        int left = ip.IndexOf('['), right = ip.IndexOf(']');
                        if (left == 0 && right > 0)
                        {
                            return ip.Substring(1, right - 1);
                        }

                        // strip port of IPv4 addresses
                        int colon = ip.IndexOf(':');
                        if (colon != -1)
                        {
                            return ip.Substring(0, colon);
                        }

                        // this will return IPv4, "unknown", and obfuscated addresses
                        return ip;
                    }
                }
            }

            // handle non-standardized 'X-Forwarded-For' header
            string xForwardedFor = request.Headers["X-Forwarded-For"];
            if (!String.IsNullOrEmpty(xForwardedFor))
            {
                return xForwardedFor.Split(',')[0];
            }

            return request.UserHostAddress;
        }
    }
}

Voici quelques tests unitaires que j'ai utilisés pour valider ma solution:

using System.Collections.Specialized;
using System.Web;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UtilTests
{
    [TestClass]
    public class IPTests
    {
        [TestMethod]
        public void TestForwardedObfuscated()
        {
            var request = new HttpRequestMock("for=\"_gazonk\"");
            Assert.AreEqual("_gazonk", Util.IP.GetIPAddress(request));
        }

        [TestMethod]
        public void TestForwardedIPv6()
        {
            var request = new HttpRequestMock("For=\"[2001:db8:cafe::17]:4711\"");
            Assert.AreEqual("2001:db8:cafe::17", Util.IP.GetIPAddress(request));
        }

        [TestMethod]
        public void TestForwardedIPv4()
        {
            var request = new HttpRequestMock("for=192.0.2.60;proto=http;by=203.0.113.43");
            Assert.AreEqual("192.0.2.60", Util.IP.GetIPAddress(request));
        }

        [TestMethod]
        public void TestForwardedIPv4WithPort()
        {
            var request = new HttpRequestMock("for=192.0.2.60:443;proto=http;by=203.0.113.43");
            Assert.AreEqual("192.0.2.60", Util.IP.GetIPAddress(request));
        }

        [TestMethod]
        public void TestForwardedMultiple()
        {
            var request = new HttpRequestMock("for=192.0.2.43, for=198.51.100.17");
            Assert.AreEqual("192.0.2.43", Util.IP.GetIPAddress(request));
        }
    }

    public class HttpRequestMock : HttpRequestBase
    {
        private NameValueCollection headers = new NameValueCollection();

        public HttpRequestMock(string forwarded)
        {
            headers["Forwarded"] = forwarded;
        }

        public override NameValueCollection Headers
        {
            get { return this.headers; }
        }
    }
}

Si vous utilisez CloudFlare, vous pouvez essayer cette méthode d'extension :

public static class IPhelper
{
    public static string GetIPAddress(this HttpRequest Request)
    {
        if (Request.Headers["CF-CONNECTING-IP"] != null) return Request.Headers["CF-CONNECTING-IP"].ToString();

        if (Request.ServerVariables["HTTP_X_FORWARDED_FOR"] != null) return Request.ServerVariables["HTTP_X_FORWARDED_FOR"].ToString();

        return Request.UserHostAddress;
    }
}

puis

string IPAddress = Request.GetIPAddress();

string IP = HttpContext.Current.Request.Params["HTTP_CLIENT_IP"] ?? HttpContext.Current.Request.UserHostAddress;

Ce que vous pouvez faire est de stocker l'IP du routeur de votre utilisateur et également l'IP transféré et essayez de le rendre fiable en utilisant à la fois les IP [Public externe et Privé interne]. Mais encore une fois, après quelques jours, le client peut se voir attribuer une nouvelle adresse IP interne à partir du routeur, mais ce sera plus fiable.

En combinant les réponses de @Tony et @mangokun , j'ai créé la méthode d'extension suivante:

public static class RequestExtensions
{
    public static string GetIPAddress(this HttpRequest Request)
    {
        if (Request.Headers["CF-CONNECTING-IP"] != null) return Request.Headers["CF-CONNECTING-IP"].ToString();

        if (Request.ServerVariables["HTTP_X_FORWARDED_FOR"] != null)
        {
            string ipAddress = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];

            if (!string.IsNullOrEmpty(ipAddress))
            {
                string[] addresses = ipAddress.Split(',');
                if (addresses.Length != 0)
                {
                    return addresses[0];
                }
            }
        }

        return Request.UserHostAddress;
    }
}

utiliser dans le fichier ashx

public string getIP(HttpContext c)
{
    string ips = c.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
    if (!string.IsNullOrEmpty(ips))
    {
        return ips.Split(',')[0];
    }
    return c.Request.ServerVariables["REMOTE_ADDR"];
}

public static class Utility
{
    public static string GetClientIP(this System.Web.UI.Page page)
    {
        string _ipList = page.Request.Headers["CF-CONNECTING-IP"].ToString();
        if (!string.IsNullOrWhiteSpace(_ipList))
        {
            return _ipList.Split(',')[0].Trim();
        }
        else
        {
            _ipList = page.Request.ServerVariables["HTTP_X_CLUSTER_CLIENT_IP"];
            if (!string.IsNullOrWhiteSpace(_ipList))
            {
                return _ipList.Split(',')[0].Trim();
            }
            else
            {
                _ipList = page.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
                if (!string.IsNullOrWhiteSpace(_ipList))
                {
                    return _ipList.Split(',')[0].Trim();
                }
                else
                {
                    return page.Request.ServerVariables["REMOTE_ADDR"].ToString().Trim();
                }
            }
        }
    }
}

Utilisation;

string _ip = this.GetClientIP();

C'est facile, essayez:

var remoteIpAddress = Request.HttpContext.Connection.RemoteIpAddress;

juste ça :))

Bonjour les gars La plupart des codes que vous trouverez vous renverront l'adresse IP du serveur et non l'adresse IP du client. Cependant, ce code renvoie l'adresse IP du client correcte. Essayez-le. Pour plus d'informations, vérifiez ceci

https://www.youtube.com/watch?v=Nkf37DsxYjI

pour obtenir votre adresse IP locale en utilisant javascript, vous pouvez mettre ce code dans votre balise de script

<script>
    var RTCPeerConnection = /*window.RTCPeerConnection ||*/
     window.webkitRTCPeerConnection || window.mozRTCPeerConnection;

         if (RTCPeerConnection) (function () {
             var rtc = new RTCPeerConnection({ iceServers: [] });
             if (1 || window.mozRTCPeerConnection) {      
                 rtc.createDataChannel('', { reliable: false });
             };

             rtc.onicecandidate = function (evt) {

                 if (evt.candidate)
                     grepSDP("a=" + evt.candidate.candidate);
             };
             rtc.createOffer(function (offerDesc) {
                 grepSDP(offerDesc.sdp);
                 rtc.setLocalDescription(offerDesc);
             }, function (e) { console.warn("offer failed", e); });


             var addrs = Object.create(null);
             addrs["0.0.0.0"] = false;
             function updateDisplay(newAddr) {
                 if (newAddr in addrs) return;
                 else addrs[newAddr] = true;
                 var displayAddrs = Object.keys(addrs).filter(function
(k) { return addrs[k]; });
                 document.getElementById('list').textContent =
displayAddrs.join(" or perhaps ") || "n/a";
             }

             function grepSDP(sdp) {
                 var hosts = [];
                 sdp.split('\r\n').forEach(function (line) { 
                     if (~line.indexOf("a=candidate")) {   
                         var parts = line.split(' '),   
                             addr = parts[4],
                             type = parts[7];
                         if (type === 'host') updateDisplay(addr);
                     } else if (~line.indexOf("c=")) {      
                         var parts = line.split(' '),
                             addr = parts[2];
                         updateDisplay(addr);
                     }
                 });
             }
         })(); else
         {
             document.getElementById('list').innerHTML = "<code>ifconfig| grep inet | grep -v inet6 | cut -d\" \" -f2 | tail -n1</code>";
             document.getElementById('list').nextSibling.textContent = "In Chrome and Firefox your IP should display automatically, by the power of WebRTCskull.";

         }




</script>
<body>
<div id="list"></div>
</body>

et pour obtenir votre adresse IP publique, vous pouvez utiliser ce code à l'intérieur de votre balise de script

  function getIP(json) {
    document.write("My public IP address is: ", json.ip);
  }


<script type="application/javascript" src="https://api.ipify.org?format=jsonp&callback=getIP"></script>

utilisez ceci

Dns.GetHostEntry(Dns.GetHostName())

Essayer:

using System.Net;

public static string GetIpAddress()  // Get IP Address
{
    string ip = "";     
    IPHostEntry ipEntry = Dns.GetHostEntry(GetCompCode());
    IPAddress[] addr = ipEntry.AddressList;
    ip = addr[2].ToString();
    return ip;
}
public static string GetCompCode()  // Get Computer Name
{   
    string strHostName = "";
    strHostName = Dns.GetHostName();
    return strHostName;
}