wake-up-neo.com

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

Ich verstehe, dass es eine Standardpraxis ist, diese beiden Variablen zu betrachten. Natürlich können sie leicht gefälscht werden. Ich bin gespannt, wie oft Sie diese Werte erwarten können (vor allem die HTTP_X_FORWARDED_FOR) um echte Informationen zu enthalten und nicht nur verschlüsselt zu werden oder ihre Werte zu verlieren?

Jemand mit den Erfahrungen oder Statistiken zu diesem Zeug?

Gibt es noch etwas, das nützlich sein kann, um die IP-Adresse des Kunden zu ermitteln?

58
User

Dies hängt von der Art Ihrer Site ab.

Ich arbeite gerade an einer Software, bei der IP-Tracking wichtig ist, und in einem Bereich, der von Parter-Sites genutzt wird, schätze ich, dass 20% - 40% der Anfragen entweder gefälschte IPs oder ausgeblendete Header sind, abhängig vom Zeitpunkt von Tag und woher sie kamen. Für eine Site, die organischen Datenverkehr erhält (d. H. Nicht über Partner), würde ich einen viel höheren Anteil an guten IPs erwarten.

Seien Sie vorsichtig, wie Kosi sagte - IPs sind in keiner Weise eine verlässliche Methode, um eindeutige Besucher zu identifizieren.

29
annakata

Zusätzlich zu REMOTE_ADDR und HTTP_X_FORWARDED_FOR Es gibt einige andere Header, die festgelegt werden können, z.

  • HTTP_CLIENT_IP
  • HTTP_X_FORWARDED_FOR kann eine durch Kommas getrennte Liste von IPs sein
  • HTTP_X_FORWARDED
  • HTTP_X_CLUSTER_CLIENT_IP
  • HTTP_FORWARDED_FOR
  • HTTP_FORWARDED

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

61
ejunker

Ich habe Grant Burtons PHP Code in eine statische ASP.Net-Methode portiert, die für die HttpRequestBase aufgerufen werden kann. Optional werden alle privaten IP-Bereiche übersprungen.

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)
    };
}
10
IDisposable

Keine richtige Antwort auf Ihre Frage, aber:
Im Allgemeinen ist es meiner Meinung nach keine gute Praxis, sich auf die IP-Adresse des Kunden zu verlassen, da es nicht möglich ist, Kunden auf einzigartige Weise zu identifizieren.

Probleme auf der Straße sind, dass es ziemlich viele Szenarien gibt, in denen die IP nicht wirklich auf einen Client ausgerichtet ist:

  • Proxy/Webfilter (fast alles zerfleischen)
  • Anonymisierungsnetzwerk (auch hier keine Chance)
  • NAT (eine interne IP ist für Sie nicht sehr nützlich)
  • ...

Ich kann keine Statistik darüber anbieten, wie viele IP-Adressen im Durchschnitt zuverlässig sind, aber was ich Ihnen sagen kann, dass es fast unmöglich ist zu sagen, ob eine bestimmte IP-Adresse die tatsächliche Adresse des Kunden ist.

7
Kosi2801

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

2
Mahesh

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

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

Das Feld X-Forwarded-For wird von den meisten Proxyservern unterstützt, darunter Squid, Apache mod_proxy, Pound, HAProxy, Lackcache, IronPort Web Security Appliance, AVANU WebMux, ArrayNetworks, Radwares AppDirector und Alteon ADC, ADC-VX und ADC- VA, F5 Big-IP, Blue Coat ProxySG, Cisco Cache-Engine, McAfee Web Gateway, Phion Airlock, Finjans wichtige Sicherheit, NetApp NetCache, jetNEXUS, Maestro von Crescendo Networks, Web Adjuster und Websense Web Security Gateway.

Wenn nicht, hier sind ein paar andere häufig verwendete Überschriften:

1
lmsurprenant

Rufen Sie die Methode Below Action in Ihrer JS-Datei auf (um die IPv4-IP-Adresse abzurufen).

    [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 dies, nachdem Sie den Haltepunkt beibehalten haben, und verwenden Sie ihn gemäß Ihren Anforderungen. Es funktioniert gut für mich.

0
TauFeeQ