मुझे ASP.NET MVC में क्लाइंट का IP पता कैसे मिल सकता है?

Question

मैं ASP.NET MVC स्टैक के लिए पूरी तरह से नया हूं, और मैं सोच रहा था कि सरल पेज ऑब्जेक्ट और रिक्वेस्ट ServerVariables ऑब्जेक्ट का क्या हुआ?

मूल रूप से, मैं क्लाइंट पीसी के आईपी पते को बाहर निकालना चाहता हूं, लेकिन मैं यह समझने में विफल हूं कि वर्तमान एमवीसी संरचना ने इस सब को कैसे बदल दिया है।

जहां तक ​​मैं समझ सकता हूं, ज्यादातर वैरिएबल ऑब्जेक्ट्स को HttpRequest वेरिएंट द्वारा बदल दिया गया है ।

किसी को कुछ संसाधनों को साझा करने की परवाह है? वास्तव में ASP.NET MVC दुनिया में सीखने के लिए सामान का एक समुद्र है। :)

उदाहरण के लिए, मेरे पास इस वर्तमान फ़ंक्शन के साथ एक स्थिर वर्ग है। मैं ASP.NET MVC का उपयोग करके समान परिणाम कैसे प्राप्त करूं?

public static int getCountry(Page page)
{
    return getCountryFromIP(getIPAddress(page));
}

public static string getIPAddress(Page page)
{
    string szRemoteAddr = page.Request.ServerVariables["REMOTE_ADDR"];
    string szXForwardedFor = page.Request.ServerVariables["X_FORWARDED_FOR"];
    string szIP = "";

    if (szXForwardedFor == null)
    {
        szIP = szRemoteAddr;
    }
    else
    {
        szIP = szXForwardedFor;

        if (szIP.IndexOf(",") > 0)
        {
            string [] arIPs = szIP.Split(',');

            foreach (string item in arIPs)
            {
                if (!isPrivateIP(item))
                {
                    return item;
                }
            }
        }
    }
    return szIP;
}

और मैं इस फ़ंक्शन को नियंत्रक पृष्ठ से कैसे कॉल करूं?

Comments

nuget.org/packages/XFF

— efaruk

stackoverflow.com/questions/21155352/…

— वरुण

Answer 1

सरल उत्तर HttpRequest.UserHostAddress संपत्ति का उपयोग करना है ।

उदाहरण: एक नियंत्रक के भीतर से:

using System;
using System.Web.Mvc;

namespace Mvc.Controllers
{
    public class HomeController : ClientController
    {
        public ActionResult Index()
        {
            string ip = Request.UserHostAddress;

            ...
        }
    }
}

उदाहरण: एक सहायक वर्ग के भीतर से:

using System.Web;

namespace Mvc.Helpers
{
    public static class HelperClass
    {
        public static string GetIPHelper()
        {
            string ip = HttpContext.Current.Request.UserHostAddress;
            ..
        }
    }
}

लेकिन, यदि अनुरोध एक, या अधिक, प्रॉक्सी सर्वरों द्वारा पारित किया गया है, तो HttpRequest.UserHostAddress संपत्ति द्वारा लौटाया गया आईपी ​​पता अंतिम प्रॉक्सी सर्वर का आईपी पता होगा जो अनुरोध को रिले करता है।

प्रॉक्सी सर्वर मई का उपयोग वास्तविक में ग्राहक के आईपी पते रखने का मानक X-Forwarded-के लिए HTTP हेडर। इसके अलावा, इस बात की कोई गारंटी नहीं है कि अनुरोध में X-Forwarded-For हैडर है, इस बात की भी कोई गारंटी नहीं है कि X-Forwarded-For SPOOFED नहीं है ।

---

मूल उत्तर

Request.UserHostAddress

उपरोक्त कोड किसी संग्रह को देखने का सहारा लिए बिना क्लाइंट का आईपी पता प्रदान करता है। अनुरोध संपत्ति नियंत्रक (या दृश्य) के भीतर उपलब्ध है। इसलिए अपने कार्य के लिए एक पृष्ठ कक्षा पास करने के बजाय आप एक ही परिणाम प्राप्त करने के लिए एक अनुरोध वस्तु पारित कर सकते हैं:

public static string getIPAddress(HttpRequestBase request)
{
    string szRemoteAddr = request.UserHostAddress;
    string szXForwardedFor = request.ServerVariables["X_FORWARDED_FOR"];
    string szIP = "";

    if (szXForwardedFor == null)
    {
        szIP = szRemoteAddr;
    }
    else
    {
        szIP = szXForwardedFor;
        if (szIP.IndexOf(",") > 0)
        {
            string [] arIPs = szIP.Split(',');

            foreach (string item in arIPs)
            {
                if (!isPrivateIP(item))
                {
                    return item;
                }
            }
        }
    }
    return szIP;
}

Comments

@ makerofthings7: कई मान हो सकते हैं क्योंकि क्लाइंट के HTTP अनुरोध के साथ कई प्रॉक्सी सर्वर अग्रेषित हो सकते हैं। यदि प्रॉक्सी सर्वर "अच्छी तरह से व्यवहार किया जाता है" (जैसा कि जानबूझकर अनाम प्रॉक्सी या बस बुरी तरह से प्रोग्राम किए गए लोगों के विपरीत), प्रत्येक XFF हेडर में पिछले एक के आईपी पर व्यवहार करेगा।

— एरिक जे।

IsPStreetIP विधि क्या करती है?

— eddiegroves

":: 1" का अर्थ है लोकलहोस्ट। बस एक आसान सा नोट।

— रात 13:05

X- फ़ॉर्वर्ड-फॉर हेडर फ़ायरवॉल और लोड बैलेंसर्स द्वारा जोड़ा जाता है जो पैकेट का विश्लेषण करते हैं और बीच में एक आदमी के रूप में कार्य करते हैं। मूल उपयोगकर्ता के आईपी पते को संरक्षित करने के लिए इस हेडर को जोड़ा जाता है ताकि मूल जानकारी को पुनः प्राप्त किया जा सके। जब पैकेट को फिर से लिखा जाता है तो नया आईपी पता आमतौर पर एक आंतरिक आईपी होता है और बहुत उपयोगी नहीं होता है।

— मार्को

धन्यवाद, इससे मुझे मदद मिली।

— जैक फेयरफील्ड

Answer 2

Request.ServerVariables["REMOTE_ADDR"] काम करना चाहिए - या तो सीधे एक दृश्य में या नियंत्रक एक्शन विधि निकाय में (अनुरोध एमवीसी में नियंत्रक वर्ग की संपत्ति है, पृष्ठ नहीं)।

यह काम कर रहा है .. लेकिन आपको एक वास्तविक IIS पर आभासी एक नहीं प्रकाशित करना होगा।

Comments

मैं इसे नियंत्रक की ओर से कैसे कॉल करूं?

— मेलाओस

योग्य, अरे जो काम करता है, क्या होगा अगर मैं इसे कक्षा की वस्तु के रूप में ऊपर रखना चाहता हूं? और क्या मुझे अभी भी पेज ऑब्जेक्ट की आवश्यकता है?

— मेलाओस

मुझे लगता है कि आप HttpContext.Current.Request

— ovolko

एड्रियन का जवाब (नीचे) बहुत बेहतर है - इसे जादू स्ट्रिंग द्वारा एक लुकअप करने की आवश्यकता नहीं है। Request.UserHostAddress

— csauve 18

यह हमेशा मेरे ऐप को चलाने वाले सर्वर का आईपी पता देता है। कोई भी कारण क्यों?

— जैक मार्केटी

Answer 3

यहां बहुत सारे कोड बहुत मददगार थे, लेकिन मैंने इसे अपने उद्देश्यों के लिए साफ कर दिया और कुछ परीक्षण जोड़े। यहाँ मैंने क्या किया:

using System;
using System.Linq;
using System.Net;
using System.Web;

public class RequestHelpers
{
    public static string GetClientIpAddress(HttpRequestBase request)
    {
        try
        {
            var userHostAddress = request.UserHostAddress;

            // Attempt to parse.  If it fails, we catch below and return "0.0.0.0"
            // Could use TryParse instead, but I wanted to catch all exceptions
            IPAddress.Parse(userHostAddress);

            var xForwardedFor = request.ServerVariables["X_FORWARDED_FOR"];

            if (string.IsNullOrEmpty(xForwardedFor))
                return userHostAddress;

            // Get a list of public ip addresses in the X_FORWARDED_FOR variable
            var publicForwardingIps = xForwardedFor.Split(',').Where(ip => !IsPrivateIpAddress(ip)).ToList();

            // If we found any, return the last one, otherwise return the user host address
            return publicForwardingIps.Any() ? publicForwardingIps.Last() : userHostAddress;
        }
        catch (Exception)
        {
            // Always return all zeroes for any failure (my calling code expects it)
            return "0.0.0.0";
        }
    }

    private static bool IsPrivateIpAddress(string ipAddress)
    {
        // http://en.wikipedia.org/wiki/Private_network
        // Private IP Addresses are: 
        //  24-bit block: 10.0.0.0 through 10.255.255.255
        //  20-bit block: 172.16.0.0 through 172.31.255.255
        //  16-bit block: 192.168.0.0 through 192.168.255.255
        //  Link-local addresses: 169.254.0.0 through 169.254.255.255 (http://en.wikipedia.org/wiki/Link-local_address)

        var ip = IPAddress.Parse(ipAddress);
        var octets = ip.GetAddressBytes();

        var is24BitBlock = octets[0] == 10;
        if (is24BitBlock) return true; // Return to prevent further processing

        var is20BitBlock = octets[0] == 172 && octets[1] >= 16 && octets[1] <= 31;
        if (is20BitBlock) return true; // Return to prevent further processing

        var is16BitBlock = octets[0] == 192 && octets[1] == 168;
        if (is16BitBlock) return true; // Return to prevent further processing

        var isLinkLocalAddress = octets[0] == 169 && octets[1] == 254;
        return isLinkLocalAddress;
    }
}

और यहाँ उस कोड के खिलाफ कुछ NUnit परीक्षण दिए गए हैं (मैं HttpRequestBase, जो M <HttpRequestBase> कॉल डाउन है) का मजाक उड़ाने के लिए राइनो मक्स का उपयोग कर रहा हूं:

using System.Web;
using NUnit.Framework;
using Rhino.Mocks;
using Should;

[TestFixture]
public class HelpersTests : TestBase
{
    HttpRequestBase _httpRequest;

    private const string XForwardedFor = "X_FORWARDED_FOR";
    private const string MalformedIpAddress = "MALFORMED";
    private const string DefaultIpAddress = "0.0.0.0";
    private const string GoogleIpAddress = "74.125.224.224";
    private const string MicrosoftIpAddress = "65.55.58.201";
    private const string Private24Bit = "10.0.0.0";
    private const string Private20Bit = "172.16.0.0";
    private const string Private16Bit = "192.168.0.0";
    private const string PrivateLinkLocal = "169.254.0.0";

    [SetUp]
    public void Setup()
    {
        _httpRequest = M<HttpRequestBase>();
    }

    [TearDown]
    public void Teardown()
    {
        _httpRequest = null;
    }

    [Test]
    public void PublicIpAndNullXForwardedFor_Returns_CorrectIp()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(null);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(GoogleIpAddress);
    }

    [Test]
    public void PublicIpAndEmptyXForwardedFor_Returns_CorrectIp()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(string.Empty);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(GoogleIpAddress);
    }

    [Test]
    public void MalformedUserHostAddress_Returns_DefaultIpAddress()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(MalformedIpAddress);
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(null);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(DefaultIpAddress);
    }

    [Test]
    public void MalformedXForwardedFor_Returns_DefaultIpAddress()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(MalformedIpAddress);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(DefaultIpAddress);
    }

    [Test]
    public void SingleValidPublicXForwardedFor_Returns_XForwardedFor()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(MicrosoftIpAddress);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(MicrosoftIpAddress);
    }

    [Test]
    public void MultipleValidPublicXForwardedFor_Returns_LastXForwardedFor()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(GoogleIpAddress + "," + MicrosoftIpAddress);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(MicrosoftIpAddress);
    }

    [Test]
    public void SinglePrivateXForwardedFor_Returns_UserHostAddress()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(Private24Bit);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(GoogleIpAddress);
    }

    [Test]
    public void MultiplePrivateXForwardedFor_Returns_UserHostAddress()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        const string privateIpList = Private24Bit + "," + Private20Bit + "," + Private16Bit + "," + PrivateLinkLocal;
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(privateIpList);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(GoogleIpAddress);
    }

    [Test]
    public void MultiplePublicXForwardedForWithPrivateLast_Returns_LastPublic()
    {
        // Arrange
        _httpRequest.Stub(x => x.UserHostAddress).Return(GoogleIpAddress);
        const string privateIpList = Private24Bit + "," + Private20Bit + "," + MicrosoftIpAddress + "," + PrivateLinkLocal;
        _httpRequest.Stub(x => x.ServerVariables[XForwardedFor]).Return(privateIpList);

        // Act
        var ip = RequestHelpers.GetClientIpAddress(_httpRequest);

        // Assert
        ip.ShouldEqual(MicrosoftIpAddress);
    }
}

Comments

यह हमेशा मेरे एप्लिकेशन को चलाने वाले सर्वर का आईपी पता देता है।

— जैक मार्केटी

क्या इसे वापस नहीं करना चाहिए publicForwardingIps.First()?

— andy250

@ नोहा मैं अनुमान लगा रहा हूं कि यह आईपीवी 6 पतों के लिए काम नहीं करेगा?

— ऐडाणो

अच्छा समाधान! IPAddress.Parse () का उपयोग अन्य IP पतों पर भी किया जाना चाहिए?

— को-डेर

Answer 4

मुझे उपरोक्त का उपयोग करने में परेशानी हुई, और मुझे एक नियंत्रक से आईपी पते की आवश्यकता थी। मैंने अंत में निम्नलिखित का उपयोग किया:

System.Web.HttpContext.Current.Request.UserHostAddress

Comments

नियंत्रक से आपको बस इतना करना थाHttpContext.Request.UserHostAddress

— सर्ज सगन

धन्यवाद। एक सहायक या एक दृश्य संदर्भ में नहीं है कि मैं एक सहायक वर्ग में क्या जरूरत थी। यह एक अच्छा सार्वभौमिक उत्तर है। +1

— पायोत्र कुला

@gander तुम्हारा क्या मतलब है? हो मैं बयान लिखना चाहिए?

— पायोटर कुल

सहायक वर्ग के शीर्ष पर, बस "System.Web का उपयोग करके" लिखें, फिर आपको केवल "HttpContext.Current.Request.UserHostAddress" लिखना होगा। सिर्फ आलसी प्रोग्रामर के लिए, खुद की तरह (और बताते हैं कि टॉम का जवाब और सर्ज की टिप्पणी क्यों)

— ganders

Answer 5

एक कक्षा में आप इसे इस तरह कह सकते हैं:

public static string GetIPAddress(HttpRequestBase request) 
{
    string ip;
    try
    {
        ip = request.ServerVariables["HTTP_X_FORWARDED_FOR"];
        if (!string.IsNullOrEmpty(ip))
        {
            if (ip.IndexOf(",") > 0)
            {
                string[] ipRange = ip.Split(',');
                int le = ipRange.Length - 1;
                ip = ipRange[le];
            }
        } else
        {
            ip = request.UserHostAddress;
        }
    } catch { ip = null; }

    return ip; 
}

मैंने इसे एक रेजर ऐप में शानदार परिणामों के साथ इस्तेमाल किया।

Comments

आप HTTP_X_FORWARDED_FOR से अंतिम पता क्यों लौटाते हैं? क्या यह ग्राहक का पता नहीं है?

— इगोर यालोवॉय

Answer 6

मैं अपनी साइट के लिए अमेजन AWS इलास्टिक लोड बैलेंसर (ELB) के पीछे कैसे खाता हूँ :

public class GetPublicIp {

    /// <summary>
    /// account for possbility of ELB sheilding the public IP address
    /// </summary>
    /// <returns></returns>
    public static string Execute() {
        try {
            Console.WriteLine(string.Join("|", new List<object> {
                    HttpContext.Current.Request.UserHostAddress,
                    HttpContext.Current.Request.Headers["X-Forwarded-For"],
                    HttpContext.Current.Request.Headers["REMOTE_ADDR"]
                })
            );

            var ip = HttpContext.Current.Request.UserHostAddress;
            if (HttpContext.Current.Request.Headers["X-Forwarded-For"] != null) {
                ip = HttpContext.Current.Request.Headers["X-Forwarded-For"];
                Console.WriteLine(ip + "|X-Forwarded-For");
            }
            else if (HttpContext.Current.Request.Headers["REMOTE_ADDR"] != null) {
                ip = HttpContext.Current.Request.Headers["REMOTE_ADDR"];
                Console.WriteLine(ip + "|REMOTE_ADDR");
            }
            return ip;
        }
        catch (Exception ex) {
            Console.Error.WriteLine(ex.Message);
        }
        return null;
    }
}