Comment puis-je vérifier si une adresse ip est un réseau en Python?

Donné une adresse ip (dire 192.168.0.1), comment puis-je vérifier si il est dans un réseau (dire 192.168.0.0/24) en Python?

Sont là des outils généraux en Python pour l'adresse ip de la manipulation? Des trucs comme hôte de recherches d'adresse ip int, adresse réseau masque réseau d'int et ainsi de suite? Espérons que dans la bibliothèque standard de Python 2.5.

Cette question semble être un bon canonique pour les très vieux 2.x les réponses, mais est obsolète pour 3.x Voir Comment organiser et d'attribuer canonicals pour “Python/pandas comparer adresse IP/CIDR”?
Je ne vois pas pourquoi; phihag de répondre à stackoverflow.com/a/1004527/1709587 est une très bonne réponse pour Python 3 et a été ici depuis 2014. J'ai roulé en arrière votre travail d'édition qui a invalidé cette réponse.

InformationsquelleAutor Staale | 2009-05-04

32

Cet article montre que vous pouvez le faire avec socket et struct modules sans trop d'effort supplémentaire. J'ai ajouté un peu de l'article comme suit:
```
import socket,struct

def makeMask(n):
    "return a mask of n bits as a long integer"
    return (2L<<n-1) - 1

def dottedQuadToNum(ip):
    "convert decimal dotted quad string to long integer"
    return struct.unpack('L',socket.inet_aton(ip))[0]

def networkMask(ip,bits):
    "Convert a network address to a long integer" 
    return dottedQuadToNum(ip) & makeMask(bits)

def addressInNetwork(ip,net):
   "Is an address in a network"
   return ip & net == net

address = dottedQuadToNum("192.168.1.1")
networka = networkMask("10.0.0.0",24)
networkb = networkMask("192.168.0.0",24)
print (address,networka,networkb)
print addressInNetwork(address,networka)
print addressInNetwork(address,networkb)
```
Ce sorties:
```
False
True
```
Si vous voulez juste une seule fonction qui prend des chaînes, il devrait ressembler à ceci:
```
import socket,struct

def addressInNetwork(ip,net):
   "Is an address in a network"
   ipaddr = struct.unpack('L',socket.inet_aton(ip))[0]
   netaddr,bits = net.split('/')
   netmask = struct.unpack('L',socket.inet_aton(netaddr))[0] & ((2L<<int(bits)-1) - 1)
   return ipaddr & netmask == netmask
```
- Je pense qu'il y a peut-être big et little endian problèmes ici, mais depuis que le réseau et la résolution des adresses ip qui se passe sur le même ordinateur, le nombre devrait avoir le même message d'erreur et au moins être dans le même endian commande.
- Bon point, bien que je ne pense pas que les "problèmes" en tant que tel. L'essentiel, c'est que stuct.déballage et prise.inet_aton à la fois par défaut pour le système de stockage de sorte que la longue vous vous retrouvez avec la volonté de toujours être OK et faire correspondre les masques créés par les makeMask fonction. Une fois que vous avez la nostalgie qu'il ne soit l'ordre dans lequel les octets sont vérifiées lorsque vous utilisez les opérateurs au niveau du bit.
- Autant que je sache inet_aton par défaut à l'ordre des octets de réseau, qui est en big endian. En fait, votre code dépend inet_aton avoir endianness face pour le système, de sorte que les premiers octets de l'adresse ip (par exemple 10 dans "10.0.0.0") aligner avec le moins significatif octets du masque (e.g 0xff dans 0x000000ff).
- En outre, struct.unpack('L',socket.inet_aton(ip))[0] s'échouer sur les architectures où " L " déballe à quelque chose de différent de 4 octets, indépendamment de l'endianness.
- Notez que cela ne fonctionne pas avec des adresses IPv6.
- En continuant sur Rafal commentaire, pour obtenir que cela fonctionne sur une version 64 bits de l'interpréteur Python, remplacez la ligne en question: return struct.unpack('<L',socket.inet_aton(ip))[0]
- Je pense que votre solution a un sérieux problème: addressInNetwork('172.7.1.1', '172.3.0.0/16') -> True (je les ai converti en " L " à "<L' dans mes os 64 bits)
- ATTENTION: Cette solution a un sérieux problème: addressInNetwork('172.7.1.1', '172.3.0.0/16') -> True
- Cette réponse a une bug. Voir la réponse: stackoverflow.com/questions/819355/...
- Je pense que les gens sont l'ajout de deux solutions: Si l'adresse IP peut être exécutée et il est actuellement affecté à un client, ou si l'IP est dans le réseau IP de gamme
- Cette réponse a deux mortels bugs: 1. d'autres ont souligné, sa logique est erreur lors de la déclaration de ip & net == net, qui renvoie true lorsque ip='11.0.1.1' et net='10.0.0.0/8'; 2. il ne fonctionne que sur little-endian lavable en même fixer le premier bug. C'est incompatible sur big-endian de la machine. La résolution est de toujours utiliser la fonction ntohl() (en python, c'est socket.ntohl()) pour convertir l'entier retourné par inet_aton(). Et après l'utilisation ntohl(), nous avons besoin de comparer le n bits au début plutôt qu'à la n bits à la fin.
InformationsquelleAutor Dave Webb
140

J'aime utiliser netaddr pour que:
```
from netaddr import CIDR, IP

if IP("192.168.0.1") in CIDR("192.168.0.0/24"):
    print "Yay!"
```
Comme arno_v souligné dans les commentaires, la nouvelle version de netaddr elle a fait comme ceci:
```
from netaddr import IPNetwork, IPAddress
if IPAddress("192.168.0.1") in IPNetwork("192.168.0.0/24"):
    print "Yay!"
```
- >>> netaddr.all_matching_cidrs("192.168.0.1", ["192.168.0.0/24","212.11.64.0/19"] ) [IPNetwork('192.168.0.0/24')]
- Ou dans la nouvelle version: de netaddr importation IPNetwork, IPAddress IPAddress("192.168.0.1") dans IPNetwork("192.168.0.0/24")
- Cette réponse est beau. Vous sir ont remporté l'internet pour la journée.
InformationsquelleAutor nosklo
109

À l'aide de ipaddress (dans la stdlib depuis 3.3, au PyPi pour 2.6/2.7):
```
>>> import ipaddress
>>> ipaddress.ip_address('192.168.0.1') in ipaddress.ip_network('192.168.0.0/24')
True
```
Si vous souhaitez évaluer un beaucoup d'adresses IP de cette façon, vous aurez probablement envie de calculer le masque de réseau d'avance, comme
```
n = ipaddress.ip_network('192.0.0.0/16')
netw = int(n.network_address)
mask = int(n.netmask)
```
Ensuite, pour chaque adresse, calculer la représentation binaire avec l'un de
```
a = int(ipaddress.ip_address('192.0.43.10'))
a = struct.unpack('!I', socket.inet_pton(socket.AF_INET, '192.0.43.10'))[0]
a = struct.unpack('!I', socket.inet_aton('192.0.43.10'))[0]  # IPv4 only
```
Enfin, vous pouvez simplement cocher:
```
in_network = (a & mask) == netw
```
- Attention, python-ipaddr se comportait assez lent pour nous, alors il peut inadaptés pour certains cas où il y a beaucoup de comparsions sont fréquemment. YMMV, donc test vous-même.
- Ajout d'une version plus rapide.
- Dans certaines versions, vous devrez fournir une chaîne unicode au lieu d'un Python str type, comme ipaddress.ip_address(u'192.168.0.1') in ipaddress.ip_network(u'192.168.0.0/24') .
- J'étais inquiète de ce que cette méthode était de parcourir la liste d'adresses dans le réseau, mais l'adresse ip du module remplace __contains__ méthode pour le faire de manière efficace, en comparant le nombre entier des représentations du réseau et les adresses de diffusion, donc rassurez-vous si c'était votre inquiétude.
InformationsquelleAutor phihag

Ce code fonctionne pour moi sur Linux x86. Je n'ai pas vraiment pensé à l'endianess questions, mais je l'ai testé contre les "ipaddr" module à l'aide de plus de 200 adresses IP testé contre 8 différentes réseau de chaînes, et les résultats de l'adresse ip sont les mêmes que le présent code.

def addressInNetwork(ip, net):
   import socket,struct
   ipaddr = int(''.join([ '%02x' % int(x) for x in ip.split('.') ]), 16)
   netstr, bits = net.split('/')
   netaddr = int(''.join([ '%02x' % int(x) for x in netstr.split('.') ]), 16)
   mask = (0xffffffff << (32 - int(bits))) & 0xffffffff
   return (ipaddr & mask) == (netaddr & mask)

Exemple:

>>> print addressInNetwork('10.9.8.7', '10.9.1.0/16')
True
>>> print addressInNetwork('10.9.8.7', '10.9.1.0/24')
False

Agréable et rapide. Pas besoin d'une bibliothèque pour quelques simples opérations logiques.

InformationsquelleAutor Sean Reifschneider

Pour python3

In [64]: ipaddress.IPv4Address('192.168.1.1') in ipaddress.IPv4Network('192.168.0.0/24')
Out[64]: False

InformationsquelleAutor okwap

6

J'ai essayé Dave Webb solution mais frapper quelques problèmes:

Plus fondamentalement, un match doit être vérifiée par ANDing l'adresse IP et le masque, puis de vérifier que le résultat correspond à l'adresse de Réseau exactement. Pas ANDing l'adresse IP avec l'adresse de Réseau comme cela a été fait.

J'ai aussi remarqué que juste ignorant la Endian comportement en supposant que la consistance vous permettra d'économiser en ne fonctionnera que pour les masques sur octet limites (/24, /16). Pour obtenir d'autres masques (/23, /21) fonctionne correctement, j'ai ajouté un "supérieur" à la structure des commandes et changé le code pour créer le masque binaire de commencer avec tous les "1" et décale à gauche par (32-masque).

Enfin, j'ai ajouté une façon simple de vérifier que l'adresse réseau est valable pour le masque et il vous suffit d'imprimer un avertissement si elle ne l'est pas.

Voici le résultat:
```
def addressInNetwork(ip,net):
    "Is an address in a network"
    ipaddr = struct.unpack('>L',socket.inet_aton(ip))[0]
    netaddr,bits = net.split('/')
    netmask = struct.unpack('>L',socket.inet_aton(netaddr))[0]
    ipaddr_masked = ipaddr & (4294967295<<(32-int(bits)))   # Logical AND of IP address and mask will equal the network address if it matches
    if netmask == netmask & (4294967295<<(32-int(bits))):   # Validate network address is valid for mask
            return ipaddr_masked == netmask
    else:
            print "***WARNING*** Network",netaddr,"not valid with mask /"+bits
            return ipaddr_masked == netmask
```
- Cela semble fonctionner de manière fiable sur 64 bits ('L' échec de la valeur est en 32 bits) et renvoie les valeurs dans un ordre logique (adresse ip sera 0xC0A80001 pour 192.168.0.1). Il a également fait face avec "192.168.0.1/24" comme un masque de réseau pour "192.168.0.1" (pas standard, mais c'est possible et facilement corrigeable)
- Fonctionne parfaitement sur Python 2.4
InformationsquelleAutor Paul McDonnell

Je ne suis pas un fan de l'utilisation de modules lorsqu'ils ne sont pas nécessaires. Ce travail ne nécessite mathématiques simples, alors voici ma fonction simple pour faire le travail:

def ipToInt(ip):
    o = map(int, ip.split('.'))
    res = (16777216 * o[0]) + (65536 * o[1]) + (256 * o[2]) + o[3]
    return res

def isIpInSubnet(ip, ipNetwork, maskLength):
    ipInt = ipToInt(ip)#my test ip, in int form

    maskLengthFromRight = 32 - maskLength

    ipNetworkInt = ipToInt(ipNetwork) #convert the ip network into integer form
    binString = "{0:b}".format(ipNetworkInt) #convert that into into binary (string format)

    chopAmount = 0 #find out how much of that int I need to cut off
    for i in range(maskLengthFromRight):
        if i < len(binString):
            chopAmount += int(binString[len(binString)-1-i]) * 2**i

    minVal = ipNetworkInt-chopAmount
    maxVal = minVal+2**maskLengthFromRight -1

    return minVal <= ipInt and ipInt <= maxVal

Puis de l'utiliser:

>>> print isIpInSubnet('66.151.97.0', '66.151.97.192',24) 
True
>>> print isIpInSubnet('66.151.97.193', '66.151.97.192',29) 
True
>>> print isIpInSubnet('66.151.96.0', '66.151.97.192',24) 
False
>>> print isIpInSubnet('66.151.97.0', '66.151.97.192',29)

C'est ça, c'est beaucoup plus rapide que les solutions ci-dessus avec les modules inclus.

{TypeError}'map' object is not subscriptable. Vous avez besoin d'un o = list(o) après o = map(int, ip.split('.'))

InformationsquelleAutor Landon

La accepté de répondre ne fonctionne pas ... ce qui me rend en colère. Le masque est en arrière et ne fonctionne pas avec tous les bits ne sont pas un simple 8 bloc de bits (par exemple /24). J'ai adapté la réponse, et il fonctionne très bien.

    import socket,struct

    def addressInNetwork(ip, net_n_bits):  
      ipaddr = struct.unpack('!L', socket.inet_aton(ip))[0]
      net, bits = net_n_bits.split('/')
      netaddr = struct.unpack('!L', socket.inet_aton(net))[0]
      netmask = (0xFFFFFFFF >> int(bits)) ^ 0xFFFFFFFF
      return ipaddr & netmask == netaddr

ici est une fonction qui retourne un pointillé chaîne binaire pour aider à visualiser le masquage.. un peu comme ipcalc de sortie.