Existe-t-il une fonction pouvant prendre une ipAddress en tant que chaîne et me dire si c’est une adresse IP non routable?

J’ai répondu à ma propre question en créant une fonction qui vérifie si une adresse IP (ipv4 ou ipv6) est une adresse ip non routable. J’ai référencé l’article wiki de l’article de McKay pour trouver beaucoup d’adresses IP réservées ( http://en.wikipedia.org/wiki/Reserved_IP_addresses )

Solution:

/// 
 /// /// 
 ///  /// A null or empty ssortingng passed as the ipAddress will return true. An invalid ipAddress will be returned as true.  ///  public static bool IsNonRoutableIpAddress(ssortingng ipAddress) { //Reference: http://en.wikipedia.org/wiki/Reserved_IP_addresses //if the ip address ssortingng is empty or null ssortingng, we consider it to be non-routable if (Ssortingng.IsNullOrEmpty(ipAddress)) { return true; } //if we cannot parse the Ipaddress, then we consider it non-routable IPAddress tempIpAddress = null; if (!IPAddress.TryParse(ipAddress, out tempIpAddress)) { return true; } byte[] ipAddressBytes = tempIpAddress.GetAddressBytes(); //if ipAddress is IPv4 if (tempIpAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { if (IsIpAddressInRange(ipAddressBytes, "10.0.0.0/8")) //Class A Private network check { return true; } else if (IsIpAddressInRange(ipAddressBytes, "172.16.0.0/12")) //Class B private network check { return true; } else if (IsIpAddressInRange(ipAddressBytes, "192.168.0.0/16")) //Class C private network check { return true; } else if (IsIpAddressInRange(ipAddressBytes, "127.0.0.0/8")) //Loopback { return true; } else if (IsIpAddressInRange(ipAddressBytes, "0.0.0.0/8")) //reserved for broadcast messages { return true; } //its routable if its ipv4 and meets none of the criteria return false; } //if ipAddress is IPv6 else if (tempIpAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6) { //incomplete if (IsIpAddressInRange(ipAddressBytes, "::/128")) //Unspecified address { return true; } else if (IsIpAddressInRange(ipAddressBytes, "::1/128")) //lookback address for localhost { return true; } else if (IsIpAddressInRange(ipAddressBytes, "2001:db8::/32")) //Addresses used in documentation { return true; } return false; } else { //we default to non-routable if its not Ipv4 or Ipv6 return true; } } /// 
 /// /// 
 ///  ///  ///  private static bool IsIpAddressInRange(byte[] ipAddressBytes, ssortingng reservedIpAddress) { if (Ssortingng.IsNullOrEmpty(reservedIpAddress)) { return false; } if (ipAddressBytes == null) { return false; } //Split the reserved ip address into a bitmask and ip address ssortingng[] ipAddressSplit = reservedIpAddress.Split(new char[] { '/' }, SsortingngSplitOptions.RemoveEmptyEnsortinges); if (ipAddressSplit.Length != 2) { return false; } ssortingng ipAddressRange = ipAddressSplit[0]; IPAddress ipAddress = null; if (!IPAddress.TryParse(ipAddressRange, out ipAddress)) { return false; } // Convert the IP address to bytes. byte[] ipBytes = ipAddress.GetAddressBytes(); //parse the bits int bits = 0; if (!int.TryParse(ipAddressSplit[1], out bits)) { bits = 0; } // BitConverter gives bytes in opposite order to GetAddressBytes(). byte[] maskBytes = null; if (ipAddress.AddressFamily == AddressFamily.InterNetwork) { uint mask = ~(uint.MaxValue >> bits); maskBytes = BitConverter.GetBytes(mask).Reverse().ToArray(); } else if (ipAddress.AddressFamily == AddressFamily.InterNetworkV6) { //128 places BitArray bitArray = new BitArray(128, false); //shift  times to the right ShiftRight(bitArray, bits, true); //turn into byte array maskBytes = ConvertToByteArray(bitArray).Reverse().ToArray(); } bool result = true; //Calculate for (int i = 0; i < ipBytes.Length; i++) { result &= (byte)(ipAddressBytes[i] & maskBytes[i]) == ipBytes[i]; } return result; } /// 
 /// /// 
 ///  ///  ///  private static void ShiftRight(BitArray bitArray, int shiftN, bool fillValue) { for (int i = shiftN; i < bitArray.Count; i++) { bitArray[i - shiftN] = bitArray[i]; } //fill the shifted bits as false for (int index = bitArray.Count - shiftN; index < bitArray.Count; index++) { bitArray[index] = fillValue; } } /// 
 /// /// 
 ///  ///  private static byte[] ConvertToByteArray(BitArray bitArray) { // pack (in this case, using the first bool as the lsb - if you want // the first bool as the msb, reverse things ;-p) int bytes = (bitArray.Length + 7) / 8; byte[] arr2 = new byte[bytes]; int bitIndex = 0; int byteIndex = 0; for (int i = 0; i < bitArray.Length; i++) { if (bitArray[i]) { arr2[byteIndex] |= (byte)(1 << bitIndex); } bitIndex++; if (bitIndex == 8) { bitIndex = 0; byteIndex++; } } return arr2; } 

Je ne peux trouver aucune autre solution, mais vous l’avez en gros: il serait préférable de vérifier les octets (obtenir l’adresse IP sous la forme d’un octet [4]) plutôt que sous la forme d’une chaîne, mais rien de plus. Rappelez-vous simplement que la classe B est 172.16.0.0/12; Là encore, il est plus facile de vérifier cela avec une valeur d’octet, car vous pouvez utiliser un masque de bits pour les quatre premiers bits du deuxième octet.

Que quelque chose soit “routable” ou non, sera basé sur une implémentation locale. Dans certains cas (comme sur le masque de sous-réseau actuel), certaines adresses sont routables, alors que d’autres ne le sont pas.

Premièrement, je vous recommande d’utiliser la classe System.Net.IPAddress:

http://msdn.microsoft.com/en-us/library/system.net.ipaddress.aspx

Consultez également l’article IP réservé dans Wikipedia.

http://en.wikipedia.org/wiki/Reserved_IP_addresses