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

Musimy Request.UserHostAddressuzyskać adres IP w ASP.NET, ale zwykle jest to adres IP dostawcy usług internetowych, a nie dokładnie adres IP komputera użytkownika, który na przykład kliknął link. Jak mogę uzyskać prawdziwy adres IP?

Na przykład w profilu użytkownika Przepełnienie stosu jest to: „Ostatnia aktywność konta: 4 godziny temu od 86.123.127.8” , ale adres IP mojej maszyny jest nieco inny. W jaki sposób przepełnienie stosu uzyskuje ten adres?

W niektórych systemach sieciowych istnieje kontrola adresu IP dla niektórych celów. Na przykład, mając określony adres IP, czy co 24 godziny użytkownik może uzyskać tylko 5 kliknięć linków do pobrania? Ten adres IP powinien być unikalny, nie dla dostawcy usług internetowych, który ma ogromną liczbę klientów lub użytkowników Internetu.

Czy dobrze zrozumiałem?

Jak powiedzieli inni, nie możesz zrobić tego, o co prosisz. Jeśli opisujesz problem, który próbujesz rozwiązać, może ktoś może pomóc?

Na przykład

• próbujesz jednoznacznie zidentyfikować swoich użytkowników?
• Czy możesz użyć pliku cookie lub identyfikatora sesji zamiast adresu IP?

EdytowaćAdres, który widzisz na serwerze, nie powinien być adresem usługodawcy internetowego, ponieważ, jak mówisz, byłby to ogromny zasięg. Adres dla użytkownika domowego korzystającego z łącza szerokopasmowego będzie adresem na jego routerze, więc każde urządzenie w domu będzie wyglądało na zewnątrz tak samo, ale router używa NAT, aby zapewnić prawidłowe kierowanie ruchu do każdego urządzenia. Dla użytkowników uzyskujących dostęp ze środowiska biurowego adres może być taki sam dla wszystkich użytkowników. Witryny, które używają adresu IP do identyfikacji, są bardzo narażone na błędy - podane przez Ciebie przykłady są dobre i często zawodzą. Na przykład moje biuro znajduje się w Wielkiej Brytanii, punktem wyjścia (gdzie „wydaje się”, że jestem w Internecie) jest w innym kraju, w którym znajduje się nasz główny ośrodek informatyczny, więc z mojego biura mój adres IP wydaje się nie znajdować w Wielkiej Brytanii. Z tego powodu nie mam dostępu do treści internetowych tylko w Wielkiej Brytanii, np. BBC iPlayer). W dowolnym momencie w mojej firmie byłyby setki, a nawet tysiące osób, które wydają się mieć dostęp do sieci z tego samego adresu IP.

Podczas pisania kodu serwera nigdy nie możesz być pewien, do jakiego adresu IP się odnosi. Niektórzy użytkownicy lubią to w ten sposób. Niektóre osoby celowo używają serwera proxy lub VPN, aby jeszcze bardziej Cię zaskoczyć.

Kiedy mówisz, że twój adres urządzenia jest inny niż adres IP pokazany na StackOverflow, jak znajdujesz adres swojego urządzenia? Jeśli szukasz tylko lokalnie ipconfiglub coś w tym stylu, spodziewam się, że będzie inaczej z powodów, które przedstawiłem powyżej. Jeśli chcesz dokładnie sprawdzić, co myśli świat zewnętrzny, zajrzyj na whatismyipaddress.com/ .

Ten link do Wikipedii na temat NAT zapewni Ci pewne podstawy na ten temat.

Często będziesz chciał znać adres IP osoby odwiedzającej twoją stronę. Chociaż ASP.NET ma kilka sposobów na zrobienie tego, jednym z najlepszych sposobów, jakie widzieliśmy, jest użycie „HTTP_X_FORWARDED_FOR” z kolekcji ServerVariables.

Dlatego...

Czasami twoi goście stoją za serwerem proxy lub routerem, a standard Request.UserHostAddressprzechwytuje tylko adres IP serwera proxy lub routera. W takim przypadku adres IP użytkownika jest następnie zapisywany w zmiennej serwera („HTTP_X_FORWARDED_FOR”).

Chcemy więc najpierw sprawdzić „HTTP_X_FORWARDED_FOR”, a jeśli jest pusty, po prostu wrócimy ServerVariables("REMOTE_ADDR").

Chociaż ta metoda nie jest niezawodna, może prowadzić do lepszych wyników. Poniżej znajduje się kod ASP.NET w VB.NET, zaczerpnięty z bloga Jamesa Crowleya „Gotcha: HTTP_X_FORWARDED_FOR zwraca wiele adresów IP”

DO#

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

AKTUALIZACJA: Dzięki Bruno Lopes. Jeśli może przyjść kilka adresów IP, musisz 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 c # patrz w ten sposób, to 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 uzyskać adresu IP.

Aktualizacja : Chociaż istnieją witryny internetowe, które używają adresu IP w celu ograniczenia użytkownika (np. Rapidshare), nie działają one poprawnie w środowiskach NAT.

Myślę, że powinienem podzielić się moim doświadczeniem z wami wszystkimi. Widzę, że w niektórych sytuacjach REMOTE_ADDR NIE dostanie tego, czego szukasz. Na przykład, jeśli masz za kulisami moduł równoważenia obciążenia i jeśli próbujesz uzyskać adres IP klienta, będziesz miał kłopoty. Sprawdziłem to za pomocą oprogramowania do maskowania IP oraz sprawdziłem, czy moi koledzy są na różnych kontynentach. Oto moje rozwiązanie.

Kiedy chcę poznać adres IP klienta, próbuję wybrać wszystkie możliwe dowody, aby ustalić, czy są one unikalne:

Tutaj znalazłem inny serwer, 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 razie, jeśli nie daje ci to wartości, powinieneś poszukać HTTP_X_FORWARDED_FOR, ponieważ jest to drugi najlepszy kandydat do uzyskania adresu IP klienta, a następnie zmienna REMOTE_ADDR, która może, ale nie musi, zwrócić Ci adres IP, ale dla mnie posiadanie tych wszystkich trzy to, co uważam za najlepszą rzecz do ich monitorowania.

Mam nadzieję, że to pomaga 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 siedmiu warstw”. Warstwa sieci może robić wszystko, co chce zrobić z adresem IP. Tak dzieje się z serwerem proxy, NAT, przekaźnikiem lub czymkolwiek innym.

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

Wszystkie dotychczasowe odpowiedzi uwzględniają niestandaryzowany, ale bardzo powszechny X-Forwarded-Fornagłówek. Istnieje znormalizowany Forwardednagłówek, który jest nieco trudniejszy do przeanalizowania. 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 uwzględnia 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 znajdują się niektóre testy jednostkowe, których użyłem do sprawdzenia poprawności 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;
    }
}

następnie

string IPAddress = Request.GetIPAddress();

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

Co możesz zrobić, to zapisać adres IP routera użytkownika, a także przekazany adres IP i postarać się, aby był niezawodny przy użyciu zarówno adresów IP [Zewnętrzny publiczny, jak i Wewnętrzny prywatny]. Ale znowu po kilku dniach klientowi 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();
                }
            }
        }
    }
}

Posługiwać się;

string _ip = this.GetClientIP();

To proste. Spróbuj:

var remoteIpAddress = Request.HttpContext.Connection.RemoteIpAddress;

po prostu to :))

Witajcie, większość kodów, które znajdziecie, zwróci wam adres IP serwera, a nie adres IP klienta. Jednak ten kod zwraca poprawny adres IP klienta. Spróbuj. Aby uzyskać więcej informacji, zaznacz to

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

Aby uzyskać lokalny adres IP za pomocą javascript, możesz użyć tego kodu w tagu skryptu

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

oraz Aby uzyskać publiczny adres IP, możesz użyć tego kodu w tagu skryptu

  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>

Użyj tego

Dns.GetHostEntry(Dns.GetHostName())

Próbować:

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