Wie kann man feststellen, ob eine IP-Adresse innerhalb eines Bereichs von IPs mit CIDR-Notation gehört?

Hier habe ich eine statische Referenz die Bereiche die ich brauche zu überprüfen:

private static List<string> Ip_Range = new List<string>()
{
    "12.144.86.0/23",
    "31.201.1.176/30",
    "46.36.198.101/32",
    "46.36.198.102/31",
    "46.36.198.104/31",
    "46.136.172.0/24",
    "63.65.11.0/24",
    "63.65.12.0/25",
    "63.65.12.128/26",
    "63.65.12.192/27",
    "63.65.12.224/28",
    "63.65.12.240/29",
    "63.65.12.248/30",
    "63.65.12.252/31",
    "63.65.12.254/32",
    "65.173.56.0/21",
    "67.23.241.179/32",
    "67.23.241.180/30",
    "67.23.241.184/29",
    "67.23.241.192/30",
    "67.23.241.196/31",
    "67.23.241.198/32",
    "72.32.164.56/29",
    "72.46.244.32/28",
    "74.91.16.48/29",
    "74.91.16.208/29",
    "74.91.20.48/28",
    "74.91.20.64/29",
    "74.112.134.120/29",
    "74.112.135.104/29",
    "74.205.37.16/29",
    "78.24.205.32/28",
    "98.129.27.88/29",
    "98.129.91.40/29",
    "166.114.0.0/16",
    "167.157.0.0/16",
    "174.143.165.80/29",
    "186.0.156.0/22",
    "186.2.0.0/17",
    "186.27.0.0/17",
    "190.0.248.0/21",
    "190.3.184.0/21"
};

Hier einige pseudo-code, wie ich es sehe funktioniert:

public static bool IpIsWithinRange(string ip) //Something like 127.0.0.1 or 184.56.26.35
{
    IPAddress incomingIp = IPAddress.Parse(ip);
    foreach (var subnet in Ip_Range)
    {
        IPAddress sub = IPAddress.Parse(subnet); ?????
        if (incomingIp "is in" sub) ?
            return true;            
    }
    return false;
}

Irgendwelche Vorschläge auf, wie code diese Funktionalität?

InformationsquelleAutor der Frage Only Bolivian Here | 2012-03-08

c#cidr ip

26

Wenn Sie nicht wollen/können nicht hinzufügen, eine andere Bibliothek (als IPnetwork) mit Ihrem Projekt gerade benötigen, um mit IPv4 CIDR-Bereiche, hier ist eine schnelle Lösung für Ihr problem
```
//true if ipAddress falls inside the CIDR range, example
//bool result = IsInRange("10.50.30.7", "10.0.0.0/8");
private bool IsInRange(string ipAddress, string CIDRmask)
{
    string[] parts = CIDRmask.Split('/');

    int IP_addr = BitConverter.ToInt32(IPAddress.Parse(parts[0]).GetAddressBytes(), 0);
    int CIDR_addr = BitConverter.ToInt32(IPAddress.Parse(ipAddress).GetAddressBytes(), 0);
    int CIDR_mask = IPAddress.HostToNetworkOrder(-1 << (32 - int.Parse(parts[1])));

    return ((IP_addr & CIDR_mask) == (CIDR_addr & CIDR_mask));
}
```
oben können Sie schnell überprüfen, ob eine gegebene IPv4-Adresse, falls innerhalb einer bestimmten CIDR-Bereich; beachten Sie, dass der obige code ist das barebone, es ist bis zu Ihnen, zu überprüfen, ob eine bestimmte IP (string) und CIDR-Bereich richtig sind, bevor Sie Sie zu füttern, um die Funktion (Sie können einfach verwenden Sie die tryparse-oder was auch immer...)

InformationsquelleAutor der Antwort ObiWan

Beschlossen, Antwort auf meine eigene Frage, damit die Menschen davon profitieren können. Wenn es verbessert werden kann, bitte tun!

Benutzte ich die IPNetwork Bibliothek und es funktionierte fantastisch! Unten ist der code, den ich verwendet:

using System.Net;

public static class RedirectHelpers
{
    public static bool IpIsWithinBoliviaRange(string ip)
    {
        IPAddress incomingIp = IPAddress.Parse(ip);
        foreach (var subnet in Bolivia_Ip_Range)
        {
            IPNetwork network = IPNetwork.Parse(subnet);

            if (IPNetwork.Contains(network, incomingIp))
                return true;
        }
        return false;
    }

    private static List<string> Bolivia_Ip_Range = new List<string>()
    {
        "12.144.86.0/23",
        "31.201.1.176/30",
        "46.36.198.101/32",
        "46.36.198.102/31",
        "46.36.198.104/31",
        "46.136.172.0/24",
        "63.65.11.0/24",
        "63.65.12.0/25",
        "63.65.12.128/26",
        "63.65.12.192/27",
        "63.65.12.224/28",
        "63.65.12.240/29",
        "63.65.12.248/30",
        "63.65.12.252/31",
        "63.65.12.254/32",
        "65.173.56.0/21",
        "67.23.241.179/32",
        "67.23.241.180/30",
        "67.23.241.184/29",
        "67.23.241.192/30",
        "67.23.241.196/31",
        "67.23.241.198/32",
        "72.32.164.56/29",
        "72.46.244.32/28",
        "74.91.16.48/29",
        "74.91.16.208/29",
        "74.91.20.48/28",
        "74.91.20.64/29",
        "74.112.134.120/29",
        "74.112.135.104/29",
        "74.205.37.16/29",
        "78.24.205.32/28",
        "98.129.27.88/29",
        "98.129.91.40/29",
        "166.114.0.0/16",
        "167.157.0.0/16",
        "174.143.165.80/29",
        "186.0.156.0/22",
        "186.2.0.0/17",
        "186.27.0.0/17",
        "190.0.248.0/21",
        "190.3.184.0/21",
        "166.114.0.0/16",
        "167.157.0.0/16",
        "186.2.0.0/18",
        "190.11.64.0/20",
        "190.11.80.0/20",
        "190.103.64.0/20",
        "190.104.0.0/19",
        "190.107.32.0/20",
        "190.129.0.0/17",
        "190.181.0.0/18",
        "190.186.0.0/18",
        "190.186.64.0/18",
        "190.186.128.0/18",
        "200.7.160.0/20",
        "200.58.64.0/20",
        "200.58.80.0/20",
        "200.58.160.0/20",
        "200.58.176.0/20",
        "200.75.160.0/20",
        "200.85.128.0/20",
        "200.87.0.0/17",
        "200.87.128.0/17",
        "200.105.128.0/19",
        "200.105.160.0/19",
        "200.105.192.0/19",
        "200.112.192.0/20",
        "200.119.192.0/20",
        "200.119.208.0/20",
        "201.222.64.0/19",
        "201.222.96.0/19"
    };
}

InformationsquelleAutor der Antwort Only Bolivian Here

9

Glücklicherweise die meiste Arbeit bereits für Sie getan (so haben wir nicht zu). Überprüfen Sie heraus die IPNetwork Projekt. Sie werden analysieren alle Ihre CIDR-Adressen mit IPNetwork.Parse. Dann zu sehen, wenn eine bestimmte IPAddress im Sortiment benutzen Sie einfach IPNetwork.Contains Methode.

Bekam ich gelangweilt, so hier ist eine Methode, die Sie verwenden können, um zu testen, ob eine IP-Adresse ist in Reichweite oder nicht:
```
private Dictionary<string, IPNetwork> netCache = null;
public bool IsInRange(string ipAddress)
{
    if (netCache == null)
        netCache = Ip_Range.ToDictionary((keyItem) => keyItem, (valueItem) => IPNetwork.Parse(valueItem));

    return netCache.Values.Any(net => IPNetwork.Contains(net, IPAddress.Parse(ipAddress)));
}
```
Dies ist abhängig von der Ip_Range Liste, aus der Frage, sondern setzt Sie IPNetwork Instanzen (fehlende Plausibilitätsprüfungen für die Kürze).

Verwendung:
```
List<string> addrList = new List<string> { "12.144.86.1", "10.254.6.172" };
addrList.ForEach(addr => Console.WriteLine("{0}: {1}", addr, IsInRange(addr)));
```
Test Ausgabe:
```
12.144.86.1: True
10.254.6.172: False
```
Natürlich gibt es noch viel, das konnte (und wahrscheinlich sollte) getan werden, aber dies beweist das Konzept.

InformationsquelleAutor der Antwort M.Babcock
3

Wenn Sie verstehen, die CIDR-notation, können Sie leicht tun die Mathematik in Ihrer Analyse-Methode.

Dass Sie im Grunde wissen, dass eine IPv4-Adresse ist 32 bit lang sind und der CIDR-notation bedeutet, dass die Anzahl der bits, die hinter dem "/" sind die Netzwerk-Adressen-bits (dh die maskierten bits), daher werden die übrig gebliebenen bits bilden die Anzahl der hosts im Subnetz.

Aus wikipedia Artikel:

Die Zahl der Adressen eines Subnetzes definiert durch die Maske oder das Präfix kann
berechnet werden 2address Größe - Präfix Größe, in denen die Adresse
Größe für IPv6 ist 128 und 32 für IPv4. Zum Beispiel, in der IPv4-Präfix
Größe /29 gibt: 232-29 = 23 = 8 Adressen.

So könnte man (Nein, ich werde nicht zu erarbeiten die details für Sie) konvertieren Sie Ihre Adressen in Binär-und tun das binäre UND mit der angegebenen Maske (auch in binärer form), dann müssen Sie die Netzwerk-Adresse Bestandteil der IP-Adresse übrig, die sollten übereinstimmung mit was auch immer-Adresse, die Sie sind, überprüft, um zu sehen, ob es in einem bestimmten Subnetz.

InformationsquelleAutor der Antwort Tony The Lion

Für start -, die Sie verwenden sollten:

IPNetwork ipnetwork = IPNetwork.Parse("192.168.168.100/29");
Console.WriteLine("CIDR: {0}", ipnetwork.Cidr);

Ausgabe

CIDR: 29

InformationsquelleAutor der Antwort RePRO

    public static bool IpIsInRange(string subnet, string ip)
    {
        var splitSubnet = subnet.Split('/');
        var maskBits = 32 - int.Parse(splitSubnet[1]);
        if (maskBits == 32)
        {
            return true;
        }
        var subnetIp = BitConverter.ToInt32(IPAddress.Parse(splitSubnet[0]).GetAddressBytes().Reverse().ToArray(), 0) >> maskBits << maskBits;
        var clientIp = BitConverter.ToInt32(IPAddress.Parse(ip).GetAddressBytes().Reverse().ToArray(), 0) >> maskBits << maskBits;
        return subnetIp == clientIp;
    }

InformationsquelleAutor der Antwort Алексей Сидоров

Ich verwenden Sie die folgenden Verfahren, um zu bestimmen, ob eine gegebene IP-Adresse eine öffentliche oder private/intern:

private bool IsInternalIpAddress(string ipAddress)
    {
        //notes: http://whatismyipaddress.com/private-ip

        var internalIpRanges = Enumerable
            .Range(16, 31)
            .Select(i => "172.{0}.".FormatWith(i))
            .Concat(new[] {"192.168.", "10.", "127."})
            .ToArray();

        return ipAddress.StartsWith(internalIpRanges);
    }

InformationsquelleAutor der Antwort Dynamic

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.