Convertir une adresse IPv4 de la notation décimale à la notation binaire#
Le but de ce TP est d’écrire des fonctions permettant de cacluler / définir des réseaux à partir d’une adresse et d’une longueur de préfixe (voir le cours).
Par exemple, l’adresse 192.168.0.1/24 signifie que cette adresse fait partie du réseau 192.168.0.0/24, qu’il contient \(2^{32 - 24} - 2 = 2^8 - 2 = 254 \) adresses, de 192.168.0.1/24 à 192.168.0.254/24, les adresses 192.168.0.0/24 et 192.168.0.255/24 étant respectivement réservées pour nommer le réseau et l’adresse de broadcast.
On peut imaginer reproduire la sortie d’un logiciel comme ipcalc
% ipcalc 192.168.0.1/24
Address: 192.168.0.1 11000000.10101000.00000000. 00000001
Netmask: 255.255.255.0 = 24 11111111.11111111.11111111. 00000000
Wildcard: 0.0.0.255 00000000.00000000.00000000. 11111111
=>
Network: 192.168.0.0/24 11000000.10101000.00000000. 00000000
HostMin: 192.168.0.1 11000000.10101000.00000000. 00000001
HostMax: 192.168.0.254 11000000.10101000.00000000. 11111110
Broadcast: 192.168.0.255 11000000.10101000.00000000. 11111111
Hosts/Net: 254 Class C, Private Internet
On peut aussi regarder des modules existants : ipcalc
Rappels#
Écrire une fonction retiregauche() qui retire les deux premiers caractères d’une chaine de caractère. On rappelle que, si s = "abc" est une chaine de caractères, alors :
s[1]\(\to\)'b's[1:]\(\to\)'bc's[:1]\(\to\)'a's + 'd'\(\to\)'abcd'[lettre for lettre in s]\(\to\)['a','b','c']
def retiregauche(chaine: str) -> str:
pass
assert retiregauche('abc') == 'c'
assert retiregauche('gauche') == 'uche'
assert retiregauche('0b11001100') == '11001100'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[2], line 1
----> 1 assert retiregauche('abc') == 'c'
2 assert retiregauche('gauche') == 'uche'
3 assert retiregauche('0b11001100') == '11001100'
AssertionError:
Écrire une fonction mybin() qui transforme un nombre entre 0 et 255 en son écriture binaire, les zéros non-significatifs devant être présents (ex: mydec(8) \(\to\) '00001000')
def mybin(entier: int) -> str:
pass
assert mybin(0) == '00000000'
assert mybin(255) == '11111111'
assert mybin(8) == '00001000'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[4], line 1
----> 1 assert mybin(0) == '00000000'
2 assert mybin(255) == '11111111'
3 assert mybin(8) == '00001000'
AssertionError:
Écrire une fonction mydec() qui prend un entier écrit en binaire (sous forme d’un string de “0” et “1”) et le convertit en un nombre décimal.
def mydec(binaire: str) -> int:
pass
assert mydec('00000000') == 0
assert mydec('11111111') == 255
assert mydec('00001000') == 8
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[6], line 1
----> 1 assert mydec('00000000') == 0
2 assert mydec('11111111') == 255
3 assert mydec('00001000') == 8
AssertionError:
Conversion d’adresses IPv4#
On va désormais chercher à convertir des adresses IPv4 en leur notation binaire correspondante. On pourra se servir des fonctions mybin() et mydec()
Écrire une fonction qui transforme une adresse IPv4 en une liste d’entiers.
def ip_int_list(ip: str) -> list:
pass
assert ip_int_list('8.8.8.8') == [8, 8, 8, 8]
assert ip_int_list('192.168.210.4') == [192, 168, 210, 4]
assert ip_int_list('127.0.0.1') == [127, 0, 0, 1]
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[8], line 1
----> 1 assert ip_int_list('8.8.8.8') == [8, 8, 8, 8]
2 assert ip_int_list('192.168.210.4') == [192, 168, 210, 4]
3 assert ip_int_list('127.0.0.1') == [127, 0, 0, 1]
AssertionError:
Écrire une fonction qui donne renvoie une chaine contenant \(n\) 1 consécutifs, suivi de \(32 - n\) 0.
def prefix_len(n: int) -> str:
pass
assert prefix_len(32) == '11111111111111111111111111111111'
assert prefix_len(24) == '11111111111111111111111100000000'
assert prefix_len(8) == '11111111000000000000000000000000'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[10], line 1
----> 1 assert prefix_len(32) == '11111111111111111111111111111111'
2 assert prefix_len(24) == '11111111111111111111111100000000'
3 assert prefix_len(8) == '11111111000000000000000000000000'
AssertionError:
Écrire une fonction qui sépare une chaine de la forme a/b en un tuple (a, b)
def ip_prefixlen(ip: str) -> tuple:
pass
assert ip_prefixlen('192.168.210.4/24') == ('192.168.210.4', '24')
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[12], line 1
----> 1 assert ip_prefixlen('192.168.210.4/24') == ('192.168.210.4', '24')
AssertionError:
Écrire une fonction qui affiche les composantes d’une adresse IPv4 en notation binaire.
def ip_list_bin(ip: str) -> str:
pass
assert ip_list_bin('192.168.210.4') == '11000000101010001101001000000100'
assert ip_list_bin('127.0.0.1') == '01111111000000000000000000000001'
assert ip_list_bin('8.8.8.8') == '00001000000010000000100000001000'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[14], line 1
----> 1 assert ip_list_bin('192.168.210.4') == '11000000101010001101001000000100'
2 assert ip_list_bin('127.0.0.1') == '01111111000000000000000000000001'
3 assert ip_list_bin('8.8.8.8') == '00001000000010000000100000001000'
AssertionError:
Écrire une fonction qui remplace les bits de la première chaine par des 0 lorsqu’ils sont à 0 dans la deuxième chaine.
def ou(chaine1: str, chaine2: str) -> str:
pass
assert ou('11000000101010001101001000000100','11111111111111111111111100000000') == '11000000101010001101001000000000'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[16], line 1
----> 1 assert ou('11000000101010001101001000000100','11111111111111111111111100000000') == '11000000101010001101001000000000'
AssertionError:
Écrire une fonction qui remplace les bits de la première chaine par des 1 lorsqu’ils sont à 0 dans la deuxième chaine.
def ouc(chaine1: str, chaine2: str) -> str:
pass
assert ouc('11000000101010001101001000000100','11111111111111111111111100000000') == '11000000101010001101001011111111'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[18], line 1
----> 1 assert ouc('11000000101010001101001000000100','11111111111111111111111100000000') == '11000000101010001101001011111111'
AssertionError:
Écrire une fonction qui sépare en octets de 8 bits et donne la transformation décimale d’une séquence de 32 bits
def bin2ip(binaire: str) -> list:
pass
assert bin2ip('11000000101010001101001000000000') == [192, 168, 210, 0]
assert bin2ip('11000000101010001101001000000100') == [192, 168, 210, 4]
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[20], line 1
----> 1 assert bin2ip('11000000101010001101001000000000') == [192, 168, 210, 0]
2 assert bin2ip('11000000101010001101001000000100') == [192, 168, 210, 4]
AssertionError:
Conclusion#
On cherche à afficher les informations liés à une addresse (avec préfixe donné).
def print_network(ip):
pass
assert print_network("192.168.210.4/24") == '192.168.210.0/24'
assert print_network("255.12.255.0/0") == '0.0.0.0/0'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[22], line 1
----> 1 assert print_network("192.168.210.4/24") == '192.168.210.0/24'
2 assert print_network("255.12.255.0/0") == '0.0.0.0/0'
AssertionError:
def print_broadcast(ip):
pass
assert print_broadcast("192.168.210.4/24") == '192.168.210.255'
assert print_broadcast("172.16.0.0/12") == '172.31.255.255'
assert print_broadcast("0.0.0.0/0") == '255.255.255.255'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Cell In[24], line 1
----> 1 assert print_broadcast("192.168.210.4/24") == '192.168.210.255'
2 assert print_broadcast("172.16.0.0/12") == '172.31.255.255'
3 assert print_broadcast("0.0.0.0/0") == '255.255.255.255'
AssertionError:
def print_hostmin(ip):
liste = bin2ip(ou(ip_list_bin(ip_prefixlen(ip)[0]),prefix_len(int(ip_prefixlen(ip)[1]))))
s = f"{liste[0]}.{liste[1]}.{liste[2]}.{liste[3] + 1}"
return s
assert print_hostmin('172.27.12.14/12') == "172.16.0.1"
assert print_hostmin('0.0.0.0/0') == '0.0.0.1'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[26], line 1
----> 1 assert print_hostmin('172.27.12.14/12') == "172.16.0.1"
2 assert print_hostmin('0.0.0.0/0') == '0.0.0.1'
Cell In[25], line 2, in print_hostmin(ip)
1 def print_hostmin(ip):
----> 2 liste = bin2ip(ou(ip_list_bin(ip_prefixlen(ip)[0]),prefix_len(int(ip_prefixlen(ip)[1]))))
3 s = f"{liste[0]}.{liste[1]}.{liste[2]}.{liste[3] + 1}"
4 return s
TypeError: 'NoneType' object is not subscriptable
def print_hostmax(ip):
liste = bin2ip(ouc(ip_list_bin(ip_prefixlen(ip)[0]),prefix_len(int(ip_prefixlen(ip)[1]))))
s = f"{liste[0]}.{liste[1]}.{liste[2]}.{liste[3] - 1}"
return s
assert print_hostmax("192.168.210.4/24") == '192.168.210.254'
assert print_hostmin('0.0.0.0/0') == '255.255.255.254'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[28], line 1
----> 1 assert print_hostmax("192.168.210.4/24") == '192.168.210.254'
2 assert print_hostmin('0.0.0.0/0') == '255.255.255.254'
Cell In[27], line 2, in print_hostmax(ip)
1 def print_hostmax(ip):
----> 2 liste = bin2ip(ouc(ip_list_bin(ip_prefixlen(ip)[0]),prefix_len(int(ip_prefixlen(ip)[1]))))
3 s = f"{liste[0]}.{liste[1]}.{liste[2]}.{liste[3] - 1}"
4 return s
TypeError: 'NoneType' object is not subscriptable