0

IP Filter Class in C#

Hello Developers, Here is IP Filter Helper Class

using System.Net;
using System.Net.Sockets;
namespace CodingJugaad.Helpers
{
    public static class IPAddressFilter
    {
        private static string SingleIP = "192.168.101.0,127.0.0.1,:;1";

        private static string RangeIP = "192.168.101.50-192.168.101.100,192.168.100.25-192.168.100.52";

        public static bool CompareIP(string ipAddress)
        {
            if (CompareSingleIP(ipAddress))
            {
                return true;
            }
            if (CompareIPInRange(ipAddress))
            {
                return true;
            }
            return false;
        }

        public static bool CompareSingleIP(string strIPAddress)
        {

            try
            {
                //Split the users IP address into it's 4 octets (Assumes IPv4) 
                string[] incomingOctets = strIPAddress.Trim().Split(new char[] { '.' });
                string[] validIpAddresses = SingleIP.Trim().Split(new char[] { ',' });

                //Iterate through each valid IP address 
                foreach (var validIpAddress in validIpAddresses)
                {
                    //Return true if valid IP address matches the users 
                    if (validIpAddress.Trim() == strIPAddress)
                    {
                        return true;
                    }

                    //Split the valid IP address into it's 4 octets 
                    string[] validOctets = validIpAddress.Trim().Split(new char[] { '.' });

                    bool matches = true;

                    //Iterate through each octet 
                    for (int index = 0; index < validOctets.Length; index++)
                    {
                        //Skip if octet is an asterisk indicating an entire 
                        //subnet range is valid 
                        if (validOctets[index] != "*")
                        {
                            if (validOctets[index] != incomingOctets[index])
                            {
                                matches = false;
                                break; //Break out of loop 
                            }
                        }
                    }

                    if (matches)
                    {
                        return true;
                    }
                }

            }
            catch (System.Exception)
            {

            }
            return false;
        }
        public static bool CompareIPInRange(string strIPAddress)
        {
            try
            {
                //Split the users IP address into it's 4 octets (Assumes IPv4) 
                string[] incomingOctets = strIPAddress.Trim().Split(new char[] { '.' });
                string[] validIpAddressesRange = RangeIP.Trim().Split(new char[] { ',' });

                //Iterate through each valid IP address 
                foreach (var validIpAddress in validIpAddressesRange)
                {
                    IPAddress beginIP = IPAddress.Parse(validIpAddress.Trim().Split(new char[] { '-' })[0]);
                    IPAddress endIP = IPAddress.Parse(validIpAddress.Trim().Split(new char[] { '-' })[1]);

                    if (IPAddressRange(beginIP, endIP, IPAddress.Parse(strIPAddress)))
                    {
                        return true;
                    }
                }

            }
            catch (System.Exception ex)
            {
                throw ex;
            }
            return false;
        }
        public static bool IPAddressRange(IPAddress lower, IPAddress upper, IPAddress address)
        {
            AddressFamily addressFamily = lower.AddressFamily;
            byte[] lowerBytes = lower.GetAddressBytes();
            byte[] upperBytes = upper.GetAddressBytes();

            if (address.AddressFamily != addressFamily)
            {
                return false;
            }
            byte[] addressBytes = address.GetAddressBytes();

            bool lowerBoundary = true, upperBoundary = true;

            for (int i = 0; i < lowerBytes.Length &&
                (lowerBoundary || upperBoundary); i++)
            {
                if ((lowerBoundary && addressBytes[i] < lowerBytes[i]) ||
                    (upperBoundary && addressBytes[i] > upperBytes[i]))
                {
                    return false;
                }

                lowerBoundary &= (addressBytes[i] == lowerBytes[i]);
                upperBoundary &= (addressBytes[i] == upperBytes[i]);
            }

            return true;
        }



    }
}

Santosh Shelar

Leave a Reply

Your email address will not be published. Required fields are marked *