Jak uzyskać adres IP klienta użytkownika w ASP.NET?

Często będziesz chciał poznać adres IP osoby odwiedzającej Twoją stronę. While ASP.NET ma kilka sposobów, aby to zrobić jednym z najlepszych sposobów, jakie widzieliśmy, jest użycie "HTTP_X_FORWARDED_FOR" kolekcji ServerVariables.

Czasami odwiedzający są za serwerem proxy lub routerem, a standardowy Request.UserHostAddress przechwytuje tylko adres IP serwera proxy lub routera. W takim przypadku adres IP użytkownika jest następnie przechowywany na serwerze zmienna ("HTTP_X_FORWARDED_FOR").

Więc to, co chcemy zrobić, to najpierw sprawdzić "HTTP_X_FORWARDED_FOR" i jeśli jest puste, po prostu zwracamy ServerVariables("REMOTE_ADDR").

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

UPDATE: Dzięki Bruno Lopesowi. Jeśli może pojawić się kilka adresów ip, należy użyć tej metody:

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

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

        return Request.ServerVariables["REMOTE_ADDR"];
    }

Jeśli jest c # patrz w ten sposób, jest bardzo proste

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

Co jeszcze uważasz za adres IP użytkownika? Jeśli chcesz adres IP karty sieciowej, obawiam się, że nie ma możliwości zrobienia tego w aplikacji internetowej. Jeśli twój użytkownik stoi za NAT lub innymi rzeczami, nie możesz też uzyskać IP.

Update: chociaż istnieją strony internetowe, które używają IP do ograniczania użytkownika( jak rapidshare), nie działają poprawnie w środowiskach NAT.

Myślę, że powinienem podzielić się z Wami moimi doświadczeniami. Widzę, że w niektórych sytuacjach REMOTE_ADDR nie dostaniesz tego, czego szukasz. Na przykład, jeśli masz Load Balancer za sceną i jeśli próbujesz uzyskać adres IP klienta, będziesz miał kłopoty. Sprawdziłem to za pomocą mojego oprogramowania do maskowania IP, a także sprawdziłem z moimi kolegami z różnych kontynentów. Oto moje rozwiązanie.

Kiedy chcę poznać IP klienta, staram się wybrać każdy możliwe dowody, więc mogę ustalić, czy są unikalne:

Tutaj znalazłem inny Sever-var, który może pomóc wszystkim, jeśli chcesz uzyskać dokładne IP po stronie klienta. więc używam: HTTP_X_CLUSTER_CLIENT_IP

HTTP_X_CLUSTER_CLIENT_IP zawsze podaje dokładny adres IP klienta. W każdym przypadku, jeśli nie daje Ci wartości, powinieneś poszukać HTTP_X_FORWARDED_FOR , ponieważ jest to drugi najlepszy kandydat, aby uzyskać adres IP klienta, a następnie REMOTE_ADDR var, który może lub nie zwróci Ci IP, ale dla mnie posiadanie wszystkich tych trzech jest najlepszą rzeczą do ich monitorowania.

Mam nadzieję, że to pomoże niektórym facetom.

Możesz użyć:

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

Adresy IP są częścią warstwy sieciowej w "stosie siedmiowarstwowym". Warstwa sieciowa może robić, co chce, z adresem IP. Tak się dzieje z serwerem proxy, NAT, relay lub czymkolwiek.

Warstwa aplikacji nie powinna w żaden sposób zależeć od adresu IP. W szczególności adres IP nie jest identyfikatorem niczego innego niż identyfikator jednego końca połączenia sieciowego. Gdy tylko połączenie zostanie zamknięte, należy spodziewać się adresu IP adres (tego samego Użytkownika) do zmiany.

Wszystkie odpowiedzi do tej pory uwzględniają niestandardowy, ale bardzo wspólny, X-Forwarded-For nagłówek. Istnieje ustandaryzowany Forwarded nagłówek, który jest nieco trudniejszy do przetworzenia. Niektóre przykłady są następujące:

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

Napisałem klasę, która bierze pod uwagę oba te nagłówki przy określaniu adresu IP klienta.

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

Poniżej kilka testów jednostkowych, których użyłem do walidacji mojego rozwiązania:

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

Jeśli używasz CloudFlare, możesz wypróbować tę metodę rozszerzenia :

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

Then

string IPAddress = Request.GetIPAddress();

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

To, co możesz zrobić, to zapisać adres IP routera użytkownika, a także adres IP przekazywany i spróbować uczynić go niezawodnym, korzystając zarówno z IPs [zewnętrzny publiczny, jak i wewnętrzny prywatny]. Ale ponownie po kilku dniach klient może zostać przypisany nowy wewnętrzny adres IP z routera, ale będzie bardziej niezawodny.

Łącząc odpowiedzi z @Tony i @ mangokun , stworzyłem następującą metodę rozszerzenia:

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

Użyj w pliku 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();
                }
            }
        }
    }
}

Use;

string _ip = this.GetClientIP();

Cześć chłopaki większość kodów, które znajdziesz zwróci ci adres IP serwera, a nie adres IP klienta .jednak ten kod zwraca poprawny adres IP klienta.Spróbuj. Aby uzyskać więcej informacji, sprawdź to

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

Aby uzyskać lokalny adres ip za pomocą javascript możesz użyć umieść ten kod wewnątrz znacznika 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>

I do uzyskania publicznego adresu ip możesz użyć umieść ten kod wewnątrz znacznika 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>

In NuGet package install Microsoft.AspNetCore.HttpOverrides Następnie spróbuj:

public class ClientDeviceInfo
    {
        private readonly IHttpContextAccessor httpAccessor;

        public ClientDeviceInfo(IHttpContextAccessor httpAccessor)
        {
            this.httpAccessor = httpAccessor;
        }

        public string GetClientLocalIpAddress()
        {
            return httpAccessor.HttpContext.Connection.LocalIpAddress.ToString();
        }

        public string GetClientRemoteIpAddress()
        {
            return httpAccessor.HttpContext.Connection.RemoteIpAddress.ToString();
        }

        public string GetClientLocalPort()
        {
            return httpAccessor.HttpContext.Connection.LocalPort.ToString();
        }

        public string GetClientRemotePort()
        {
            return httpAccessor.HttpContext.Connection.RemotePort.ToString();
        }
     }

To proste.Spróbuj:

var remoteIpAddress = Request.HttpContext.Connection.RemoteIpAddress;

Po Prostu:))

Użyj tego

Dns.GetHostEntry(Dns.GetHostName())

Spróbuj:

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