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

Question

Étant donné une adresse IP (disons 192.168.0.1), comment puis-je vérifier si elle est dans un réseau (disons 192.168.0.0/24) en Python ?

Existe-t-il des outils généraux en Python pour la manipulation des adresses IP ? Des choses comme la recherche d'hôtes, l'adresse IP en int, l'adresse réseau avec le masque de réseau en int, etc ? Avec un peu de chance, dans la bibliothèque Python standard de la version 2.5.

Answer 1

Utilisation de adresse IP ( dans la stdlib depuis 3.3 , à 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 voulez évaluer un lot d'adresses IP de cette manière, vous voudrez probablement calculer le masque de réseau à l'avance, comme suit

n = ipaddress.ip_network('192.0.0.0/16')
netw = int(n.network_address)
mask = int(n.netmask)

Ensuite, pour chaque adresse, calculez la représentation binaire avec l'une des méthodes suivantes

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 vérifier :

in_network = (a & mask) == netw

Answer 2

J'aime utiliser netaddr pour ça :

from netaddr import CIDR, IP

if IP("192.168.0.1") in CIDR("192.168.0.0/24"):
    print "Yay!"

Comme arno_v l'a souligné dans les commentaires, la nouvelle version de netaddr le fait de cette façon :

from netaddr import IPNetwork, IPAddress
if IPAddress("192.168.0.1") in IPNetwork("192.168.0.0/24"):
    print "Yay!"

Answer 3

Cet article montre que vous pouvez le faire avec socket y struct sans trop d'efforts supplémentaires. J'ai ajouté un peu à 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)

Ces sorties :

False
True

Si vous voulez juste une fonction unique qui prend des chaînes de caractères, cela ressemblerait à 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

Answer 4

Ce code fonctionne pour moi sur Linux x86. Je n'ai pas vraiment réfléchi aux problèmes d'endianess, mais je l'ai testé par rapport au module "ipaddr" en utilisant plus de 200K adresses IP testées par rapport à 8 chaînes réseau différentes, et les résultats d'ipaddr sont les mêmes que ce 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

Answer 5

J'ai essayé la solution de Dave Webb mais j'ai rencontré quelques problèmes :

Plus fondamentalement, une correspondance doit être vérifiée en faisant un ET entre l'adresse IP et le masque, puis en vérifiant que le résultat correspond exactement à l'adresse réseau. Et non pas en faisant un ET entre l'adresse IP et l'adresse réseau comme cela a été fait.

J'ai également remarqué que le fait d'ignorer le comportement de l'Endian en supposant que la cohérence vous sauvera ne fonctionne que pour les masques sur les limites d'octets (/24, /16). Pour que les autres masques (/23, /21) fonctionnent correctement, j'ai ajouté un "plus grand que" aux commandes struct et j'ai modifié le code de création du masque binaire pour commencer par tous les "1" et décaler à gauche par (32-mask).

Enfin, j'ai ajouté une simple vérification que l'adresse réseau est valide pour le masque et j'ai simplement imprimé un avertissement si ce n'est pas le cas.

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