Como obter o endereço IP do cliente de um usuário no ASP.NET?

Temos que Request.UserHostAddressobter o endereço IP no ASP.NET, mas esse geralmente é o endereço IP do ISP do usuário, não exatamente o endereço IP da máquina do usuário que, por exemplo, clicou em um link. Como posso obter o endereço IP real?

Por exemplo, em um perfil de usuário do Stack Overflow, é: "Última atividade da conta: há 4 horas de 86.123.127.8" , mas o endereço IP da minha máquina é um pouco diferente. Como o Stack Overflow obtém esse endereço?

Em alguns sistemas web, há uma verificação de endereço IP para alguns propósitos. Por exemplo, com um determinado endereço IP, a cada 24 horas o usuário pode ter apenas 5 cliques nos links de download? Esse endereço IP deve ser exclusivo, não para um provedor de serviços de Internet que tenha uma enorme variedade de clientes ou usuários da Internet.

Eu entendi bem?

Como outros já disseram, você não pode fazer o que está pedindo. Se você descrever o problema que está tentando resolver, talvez alguém possa ajudar?

Por exemplo

• você está tentando identificar exclusivamente seus usuários?
• Você poderia usar um cookie ou o ID da sessão, talvez, em vez do endereço IP?

EditarO endereço que você vê no servidor não deve ser o endereço do ISP, pois você diz que seria um intervalo enorme. O endereço para um usuário doméstico em banda larga será o endereço no roteador; portanto, todos os dispositivos internos parecerão iguais, mas o roteador usa o NAT para garantir que o tráfego seja roteado corretamente para cada dispositivo. Para usuários acessando de um ambiente de escritório, o endereço pode ser o mesmo para todos os usuários. Os sites que usam o endereço IP para identificação correm o risco de cometer erros muito graves - os exemplos que você dá são bons e geralmente falham. Por exemplo, meu escritório está no Reino Unido, o ponto de interrupção (onde "pareço estar" na Internet) está em outro país onde nossa principal instalação de TI está; portanto, do meu escritório, meu endereço IP parece não estar no Reino Unido. Por esse motivo, não consigo acessar apenas o conteúdo da web do Reino Unido, como o BBC iPlayer). A qualquer momento, centenas ou mesmo milhares de pessoas na minha empresa parecem acessar a web a partir do mesmo endereço IP.

Ao escrever o código do servidor, você nunca pode ter certeza a que se refere o endereço IP que vê. Alguns usuários gostam desta maneira. Algumas pessoas usam deliberadamente um proxy ou VPN para confundi-lo ainda mais.

Quando você diz que o endereço da sua máquina é diferente do endereço IP mostrado no StackOverflow, como está descobrindo o endereço da sua máquina? Se você está apenas procurando localmente usando ipconfigalgo assim, eu esperaria que fosse diferente pelas razões descritas acima. Se você quiser verificar o que o mundo exterior pensa, dê uma olhada no whatismyipaddress.com/ .

Este link da Wikipedia no NAT fornecerá algumas informações sobre isso.

Muitas vezes, você deseja saber o endereço IP de alguém que visita seu site. Embora o ASP.NET tenha várias maneiras de fazer isso, uma das melhores maneiras que vimos é usar o "HTTP_X_FORWARDED_FOR" da coleção ServerVariables.

Aqui está o porquê...

Às vezes, seus visitantes estão atrás de um servidor proxy ou de um roteador e o padrão Request.UserHostAddresscaptura apenas o endereço IP do servidor ou roteador proxy. Quando esse for o caso, o endereço IP do usuário será armazenado na variável do servidor ("HTTP_X_FORWARDED_FOR").

Então, o que queremos fazer é primeiro verificar "HTTP_X_FORWARDED_FOR" e, se estiver vazio, simplesmente retornamos ServerVariables("REMOTE_ADDR").

Embora esse método não seja infalível, ele pode levar a melhores resultados. Abaixo está o código ASP.NET no VB.NET, obtido na postagem do blog de James Crowley "Gotcha: HTTP_X_FORWARDED_FOR retorna vários endereços 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

ATUALIZAÇÃO: Obrigado a Bruno Lopes. Se vários endereços IP vierem, é necessário usar este método:

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

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

        return Request.ServerVariables["REMOTE_ADDR"];
    }

Se for c # veja dessa maneira, é muito simples

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

O que mais você considera o endereço IP do usuário? Se você deseja o endereço IP do adaptador de rede, receio que não haja maneira possível de fazer isso em um aplicativo Web. Se o seu usuário estiver com NAT ou outras coisas, você também não poderá obter o IP.

Atualização : Embora existam sites que usam IP para limitar o usuário (como o rapidshare), eles não funcionam corretamente em ambientes NAT.

Acho que devo compartilhar minha experiência com todos vocês. Bem, em algumas situações, o REMOTE_ADDR NÃO dará o que você está procurando. Por exemplo, se você tiver um Balanceador de Carga nos bastidores e se estiver tentando obter o IP do Cliente, estará em apuros. Eu verifiquei com meu software de máscara de IP e também com meus colegas em diferentes continentes. Então aqui está a minha solução.

Quando quero saber o IP de um cliente, tento escolher todas as evidências possíveis para determinar se elas são únicas:

Aqui encontrei outro sever-var que poderia ajudar a todos, se você deseja obter o IP exato do lado do cliente. então estou usando: HTTP_X_CLUSTER_CLIENT_IP

HTTP_X_CLUSTER_CLIENT_IP sempre fornece o IP exato do cliente. De qualquer forma, se não fornecer o valor, você deve procurar HTTP_X_FORWARDED_FOR , pois é o segundo melhor candidato para obter o IP do cliente e, em seguida, o REMOTE_ADDR var que pode ou não retornar o IP, mas para mim, tendo tudo isso três é o que acho melhor para monitorá-los.

Espero que isso ajude alguns caras.

Você pode usar:

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

Os endereços IP fazem parte da camada de rede na "pilha de sete camadas". A camada de rede pode fazer o que quiser com o endereço IP. É o que acontece com um servidor proxy, NAT, retransmissão ou o que for.

A camada de aplicativo não deve depender do endereço IP de forma alguma. Em particular, um endereço IP não deve ser um identificador de outra coisa senão o identificador mais adequado de uma extremidade de uma conexão de rede. Assim que uma conexão é fechada, você deve esperar que o endereço IP (do mesmo usuário) mude.

Até agora, todas as respostas levam em consideração o cabeçalho não padronizado, mas muito comum X-Forwarded-For. Existe um Forwardedcabeçalho padronizado que é um pouco mais difícil de analisar. Alguns exemplos são os seguintes:

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

Eu escrevi uma classe que leva em consideração esses dois cabeçalhos ao determinar o endereço IP de um cliente.

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

Abaixo estão alguns testes de unidade que eu usei para validar minha solução:

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

Se você estiver usando o CloudFlare, poderá tentar este método de extensão :

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

então

string IPAddress = Request.GetIPAddress();

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

O que você pode fazer é armazenar o IP do roteador do seu usuário e também o IP encaminhado e tentar torná-lo confiável usando os dois IPs [Público externo e Privado interno]. Mas novamente depois de alguns dias, o cliente pode receber um novo IP interno do roteador, mas ele será mais confiável.

Combinando as respostas de @Tony e @mangokun , eu criei o método de extensão a seguir:

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

usar no arquivo 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();
                }
            }
        }
    }
}

Usar;

string _ip = this.GetClientIP();

É fácil.Tente:

var remoteIpAddress = Request.HttpContext.Connection.RemoteIpAddress;

só isso :))

Olá pessoal A maioria dos códigos que você encontrará retornará o endereço IP do servidor e não o endereço IP do cliente. De qualquer forma esse código retornará o endereço IP do cliente correto. Para obter mais informações, basta verificar isso

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

para obter seu endereço IP local usando javascript, você pode colocar esse código dentro da sua tag 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>

e Para obter seu endereço IP público, você pode usar esse código dentro da sua tag 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>

usa isto

Dns.GetHostEntry(Dns.GetHostName())

Tentar:

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