Come ottenere l'indirizzo IP del client di un utente in ASP.NET?

Dobbiamo Request.UserHostAddressottenere l'indirizzo IP in ASP.NET, ma di solito si tratta dell'indirizzo IP dell'ISP dell'utente, non esattamente dell'indirizzo IP della macchina dell'utente che, ad esempio, ha fatto clic su un collegamento. Come posso ottenere il vero indirizzo IP?

Ad esempio, in un profilo utente Stack Overflow è: "Ultima attività dell'account: 4 ore fa da 86.123.127.8" , ma l'indirizzo IP della mia macchina è leggermente diverso. In che modo Stack Overflow ottiene questo indirizzo?

In alcuni sistemi Web esiste un controllo dell'indirizzo IP per alcuni scopi. Ad esempio, con un determinato indirizzo IP, per ogni 24 ore l'utente può avere solo 5 clic sui collegamenti di download? Questo indirizzo IP dovrebbe essere univoco, non per un ISP che ha una vasta gamma di client o utenti Internet.

Ho capito bene?

Come altri hanno già detto, non puoi fare quello che stai chiedendo. Se descrivi il problema che stai cercando di risolvere, forse qualcuno può aiutarti?

Per esempio

• stai cercando di identificare in modo univoco i tuoi utenti?
• Potresti usare un cookie o forse l'ID di sessione invece dell'indirizzo IP?

modificareL'indirizzo che vedi sul server non dovrebbe essere l'indirizzo dell'ISP, poiché dici che sarebbe un intervallo enorme. L'indirizzo per un utente di casa sulla banda larga sarà l'indirizzo del proprio router, quindi ogni dispositivo all'interno della casa apparirà all'esterno per essere lo stesso, ma il router utilizza NAT per garantire che il traffico venga instradato correttamente a ciascun dispositivo. Per gli utenti che accedono da un ambiente di ufficio l'indirizzo potrebbe essere lo stesso per tutti gli utenti. I siti che utilizzano l'indirizzo IP per l'ID corrono il rischio di sbagliarlo: gli esempi forniti sono validi e spesso falliscono. Ad esempio, il mio ufficio è nel Regno Unito, il punto di rottura (dove "mi sembra" di essere su Internet) è in un altro paese in cui si trova la nostra struttura IT principale, quindi dal mio ufficio il mio indirizzo IP sembra non essere nel Regno Unito. Per questo motivo non riesco ad accedere al solo contenuto web del Regno Unito, come BBC iPlayer). In qualsiasi momento ci sarebbero centinaia o addirittura migliaia di persone nella mia azienda che sembrano accedere al Web dallo stesso indirizzo IP.

Quando scrivi il codice del server non puoi mai essere sicuro di quale indirizzo IP stai vedendo. Ad alcuni utenti piace così. Alcune persone usano deliberatamente un proxy o una VPN per confonderti ulteriormente.

Quando dici che il tuo indirizzo macchina è diverso dall'indirizzo IP mostrato su StackOverflow, come stai scoprendo il tuo indirizzo macchina? Se stai solo guardando localmente usando ipconfigo qualcosa del genere, mi aspetto che sia diverso per i motivi che ho descritto sopra. Se vuoi ricontrollare cosa pensa il mondo esterno dai un'occhiata a whatismyipaddress.com/ .

Questo link di Wikipedia su NAT ti fornirà alcune informazioni al riguardo.

Spesso vorrai conoscere l'indirizzo IP di qualcuno che visita il tuo sito web. Mentre ASP.NET ha diversi modi per farlo, uno dei modi migliori che abbiamo visto è usare "HTTP_X_FORWARDED_FOR" della raccolta ServerVariables.

Ecco perché...

A volte i visitatori si trovano dietro un server proxy o un router e lo standard Request.UserHostAddressacquisisce solo l'indirizzo IP del server proxy o del router. In questo caso, l'indirizzo IP dell'utente viene quindi memorizzato nella variabile del server ("HTTP_X_FORWARDED_FOR").

Quindi quello che vogliamo fare è prima controllare "HTTP_X_FORWARDED_FOR" e se quello è vuoto, allora semplicemente ritorniamo ServerVariables("REMOTE_ADDR").

Sebbene questo metodo non sia infallibile, può portare a risultati migliori. Di seguito è riportato il codice ASP.NET in VB.NET, tratto dal post sul blog di James Crowley "Gotcha: HTTP_X_FORWARDED_FOR restituisce più indirizzi 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

AGGIORNAMENTO: Grazie a Bruno Lopes. Se potrebbero venire più indirizzi IP, è necessario utilizzare questo metodo:

    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 è c # vedere in questo modo, è molto semplice

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

Cos'altro consideri l'indirizzo IP dell'utente? Se desideri l'indirizzo IP della scheda di rete, temo che non sia possibile farlo in un'app Web. Se l'utente si trova dietro NAT o altre cose, non è nemmeno possibile ottenere l'IP.

Aggiornamento : mentre ci sono siti Web che utilizzano l'IP per limitare l'utente (come rapidshare), non funzionano correttamente negli ambienti NAT.

Penso che dovrei condividere la mia esperienza con tutti voi. Bene, vedo in alcune situazioni che REMOTE_ADDR NON ti darà quello che stai cercando. Ad esempio, se si dispone di un bilanciamento del carico dietro la scena e se si sta tentando di ottenere l'IP del cliente, si avranno problemi. L'ho verificato con il mio software di mascheramento IP e ho anche verificato che i miei colleghi si trovassero in diversi continenti. Quindi ecco la mia soluzione.

Quando voglio conoscere l'IP di un client, provo a raccogliere tutte le prove possibili in modo da poter determinare se sono univoci:

Qui ho trovato un altro sever-var che potrebbe aiutarti tutti se vuoi ottenere l'IP esatto del lato client. quindi sto usando: HTTP_X_CLUSTER_CLIENT_IP

HTTP_X_CLUSTER_CLIENT_IP ti fornisce sempre l'IP esatto del client. In ogni caso, se non ti dà il valore, dovresti quindi cercare HTTP_X_FORWARDED_FOR in quanto è il secondo miglior candidato a procurarti l'IP del client e quindi la var REMOTE_ADDR che può o meno restituirti l'IP ma a me avere tutti questi tre è quello che trovo la cosa migliore per monitorarli.

Spero che questo aiuti alcuni ragazzi.

Puoi usare:

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

Gli indirizzi IP fanno parte del livello Network nello "stack a sette livelli". Il livello Rete può fare qualsiasi cosa voglia fare con l'indirizzo IP. Questo è ciò che accade con un server proxy, NAT, relay o altro.

Il livello applicazione non dovrebbe dipendere in alcun modo dall'indirizzo IP. In particolare, un indirizzo IP non è pensato per essere un identificatore di qualcosa di diverso dall'identificatore di un'estremità di una connessione di rete. Non appena viene chiusa una connessione, dovresti aspettarti che l'indirizzo IP (dello stesso utente) cambi.

Tutte le risposte finora tengono conto dell'intestazione non standardizzata, ma molto comune X-Forwarded-For. C'è Forwardedun'intestazione standardizzata che è un po 'più difficile da analizzare. Alcuni esempi sono i seguenti:

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

Ho scritto una classe che tiene conto di entrambe queste intestazioni nel determinare l'indirizzo IP di 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;
        }
    }
}

Di seguito sono riportati alcuni test unit che ho usato per convalidare la mia soluzione:

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 stai usando CloudFlare, puoi provare questo metodo di estensione :

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

poi

string IPAddress = Request.GetIPAddress();

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

Quello che puoi fare è archiviare l'IP del router del tuo utente e anche l'IP inoltrato e provare a renderlo affidabile utilizzando entrambi gli IP [esterno pubblico e interno privato]. Ma dopo alcuni giorni al client potrebbe essere assegnato un nuovo IP interno dal router, ma sarà più affidabile.

Combinando le risposte di @Tony e @mangokun , ho creato il seguente metodo di estensione:

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

utilizzare nel file 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();
                }
            }
        }
    }
}

Uso;

string _ip = this.GetClientIP();

È facile. Provalo:

var remoteIpAddress = Request.HttpContext.Connection.RemoteIpAddress;

solo :))

Ciao ragazzi La maggior parte dei codici che troverete restituiranno l'indirizzo IP del vostro server non l'indirizzo IP del client. Tuttavia, questo codice restituisce l'indirizzo IP client corretto. Provatelo. Per maggiori informazioni basta controllare questo

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

per ottenere il tuo indirizzo IP locale tramite JavaScript puoi usare questo codice all'interno del tag dello 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 per ottenere il tuo indirizzo IP pubblico puoi usare questo codice all'interno del tag dello 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 questo

Dns.GetHostEntry(Dns.GetHostName())

Provare:

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