Abrufen der Client-IP-Adresse: REMOTE_ADDR, HTTP_X_FORWARDED_FOR, was sonst noch nützlich sein könnte?

StackOverflow https://stackoverflow.com/questions/527638

Frage

Ich verstehe, es ist eine gängige Praxis dieser Variablen beide zu betrachten. Natürlich können sie leicht gefälscht werden. Ich bin gespannt, wie oft können Sie diese Werte (vor allem die HTTP_X_FORWARDED_FOR) erwarten echte Informationen zu enthalten und nicht nur verschlüsselt werden oder haben ihre Werte abgestreift?

Jeder, der Erfahrung oder Statistiken über dieses Zeug?

Gibt es noch etwas, dass die Kunden für die Aufgabe des Erhaltens IP-Adresse nützlich sein kann?

War es hilfreich?

Lösung

Es hängt von der Art Ihrer Website.

ich zufällig auf ein bisschen Software arbeiten, wo IP-Tracking wichtig ist, und innerhalb eines Feldes von parter Stellen verbraucht würde ich etwa 20% erraten - 40% der Anfragen werden entweder detektierbar spoofed IPs oder Header ausgeblendet, je nachdem, die Tageszeit und woher sie kamen. Für eine Website, die Bio-Verkehr (das heißt nicht durch Partner) bekommt würde ich ein viel höheres Verhältnis von gutem IPs erwartet.

Wie Kosi sagte, seien Sie vorsichtig, was Sie mit das tun -. IPs sind in keiner Weise eine zuverlässige Möglichkeit, Besucher zu identifizieren

Andere Tipps

Neben REMOTE_ADDR und HTTP_X_FORWARDED_FOR gibt es einige andere Header, die eingestellt werden können, wie zum Beispiel:

  • HTTP_CLIENT_IP
  • kann HTTP_X_FORWARDED_FOR Liste der IP-Adressen begrenzt Komma
  • HTTP_X_FORWARDED
  • HTTP_X_CLUSTER_CLIENT_IP
  • HTTP_FORWARDED_FOR
  • HTTP_FORWARDED

fand ich den Code auf der folgenden Website nützlich:
http://www.grantburton.com/?p=97

Ich habe portiert PHP-Code Grant Burton auf eine ASP.Net statische Methode aufrufbar gegen die Httprequestbase. Es wird gegebenenfalls durch alle privaten IP-Bereiche überspringen. 

public static class ClientIP
{
    // based on http://www.grantburton.com/2008/11/30/fix-for-incorrect-ip-addresses-in-wordpress-comments/
    public static string ClientIPFromRequest(this HttpRequestBase request, bool skipPrivate)
    {
        foreach (var item in s_HeaderItems)
        {
            var ipString = request.Headers[item.Key];

        if (String.IsNullOrEmpty(ipString))
            continue;

        if (item.Split)
        {
            foreach (var ip in ipString.Split(','))
                if (ValidIP(ip, skipPrivate))
                    return ip;
        }
        else
        {
            if (ValidIP(ipString, skipPrivate))
                return ipString;
        }
    }

    return request.UserHostAddress;
}

private static bool ValidIP(string ip, bool skipPrivate)
{
    IPAddress ipAddr;

    ip = ip == null ? String.Empty : ip.Trim();

    if (0 == ip.Length
        || false == IPAddress.TryParse(ip, out ipAddr)
        || (ipAddr.AddressFamily != AddressFamily.InterNetwork
            && ipAddr.AddressFamily != AddressFamily.InterNetworkV6))
        return false;

    if (skipPrivate && ipAddr.AddressFamily == AddressFamily.InterNetwork)
    {
        var addr = IpRange.AddrToUInt64(ipAddr);
        foreach (var range in s_PrivateRanges)
        {
            if (range.Encompasses(addr))
                return false;
        }
    }

    return true;
}

/// <summary>
/// Provides a simple class that understands how to parse and
/// compare IP addresses (IPV4) ranges.
/// </summary>
private sealed class IpRange
{
    private readonly UInt64 _start;
    private readonly UInt64 _end;

    public IpRange(string startStr, string endStr)
    {
        _start = ParseToUInt64(startStr);
        _end = ParseToUInt64(endStr);
    }

    public static UInt64 AddrToUInt64(IPAddress ip)
    {
        var ipBytes = ip.GetAddressBytes();
        UInt64 value = 0;

        foreach (var abyte in ipBytes)
        {
            value <<= 8;    // shift
            value += abyte;
        }

        return value;
    }

    public static UInt64 ParseToUInt64(string ipStr)
    {
        var ip = IPAddress.Parse(ipStr);
        return AddrToUInt64(ip);
    }

    public bool Encompasses(UInt64 addrValue)
    {
        return _start <= addrValue && addrValue <= _end;
    }

    public bool Encompasses(IPAddress addr)
    {
        var value = AddrToUInt64(addr);
        return Encompasses(value);
    }
};

private static readonly IpRange[] s_PrivateRanges =
    new IpRange[] { 
            new IpRange("0.0.0.0","2.255.255.255"),
            new IpRange("10.0.0.0","10.255.255.255"),
            new IpRange("127.0.0.0","127.255.255.255"),
            new IpRange("169.254.0.0","169.254.255.255"),
            new IpRange("172.16.0.0","172.31.255.255"),
            new IpRange("192.0.2.0","192.0.2.255"),
            new IpRange("192.168.0.0","192.168.255.255"),
            new IpRange("255.255.255.0","255.255.255.255")
    };


/// <summary>
/// Describes a header item (key) and if it is expected to be 
/// a comma-delimited string
/// </summary>
private sealed class HeaderItem
{
    public readonly string Key;
    public readonly bool Split;

    public HeaderItem(string key, bool split)
    {
        Key = key;
        Split = split;
    }
}

// order is in trust/use order top to bottom
private static readonly HeaderItem[] s_HeaderItems =
    new HeaderItem[] { 
            new HeaderItem("HTTP_CLIENT_IP",false),
            new HeaderItem("HTTP_X_FORWARDED_FOR",true),
            new HeaderItem("HTTP_X_FORWARDED",false),
            new HeaderItem("HTTP_X_CLUSTER_CLIENT_IP",false),
            new HeaderItem("HTTP_FORWARDED_FOR",false),
            new HeaderItem("HTTP_FORWARDED",false),
            new HeaderItem("HTTP_VIA",false),
            new HeaderItem("REMOTE_ADDR",false)
    };
}

Keine wirkliche Antwort auf Ihre Frage, aber:
Im Allgemeinen unter Berufung auf den Clients IP-Adresse meiner Meinung nach ist keine gute Praxis, da es nicht verwendbar ist, Kunden in einer einzigartigen Art und Weise zu identifizieren.

Probleme auf der Straße sind, dass es ziemlich viele Szenarien, in denen die IP nicht wirklich an einen Kunden auszurichten:

  • Proxy / Webfilter (mangle fast alles)
  • Anonymizer Netzwerk (keine Chance hier entweder)
  • NAT (eine interne IP ist nicht sehr nützlich für Sie)
  • ...

Ich kann keine Statistiken bieten, wie viele IP-Adressen sind im Durchschnitt zuverlässig, aber was ich kann Ihnen sagen, dass es fast unmöglich ist, zu sagen, ob eine bestimmte IP-Adresse ist die wirklichen Kunden adressieren.

IP + "User Agent" könnte besser für eindeutige Besucher.

Wenn Sie hinter einem Proxy sind, sollten Sie X-Forwarded-For verwenden: http: // en .wikipedia.org / wiki / X-Forwarded-For

Es ist ein IETF Draft Standard mit breiter Unterstützung:

  

Die X-Forwarded-For-Feld von den meisten Proxy-Server unterstützt wird,   einschließlich Squid, Apache mod_proxy, Pound, HAProxy, Varnish Cache,   Ironport Web Security Appliance, AVANU Webmux, ArrayNetworks,   Radware AppDirector und Alteon ADC, ADC-VX und ADC-VA, F5 Big-IP,   Blue Coat ProxySG, Cisco Cache Engine McAfee Web Gateway, Phion   Airlock, Finjan Vital Security, NetApp NetCache, jetNEXUS, Crescendo   Networks' Maestro, Gurteinstellers und Websense Web Security Gateway.

Wenn nicht, hier sind ein paar andere gemeinsame Header ich gesehen habe:

Rufen Sie die Unten Aktion Methode aus Ihrer JS-Datei (zur IPv4 IP-Adresse zu erhalten). 

    [HttpGet]
    public string GetIP()
    {
        IPAddress[] ipv4Addresses = Array.FindAll(
            Dns.GetHostEntry(string.Empty).AddressList,
            a => a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
        return ipv4Addresses.ToString();
    }

Überprüfen Sie nach dem Haltepunkt zu halten, und verwenden Sie wie pro Ihre Anforderung. Seine Arbeit für mich in Ordnung.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top