Sous-réseautage IP et conversion binaire dans le terminal Linux

Introduction

Dans ce laboratoire, vous maîtriserez les compétences essentielles de la segmentation d'adresses IP et de la conversion binaire à l'aide de la ligne de commande Linux. En exploitant l'interpréteur interactif Python, vous acquerrez une expérience pratique des calculs fondamentaux qui sous-tendent les réseaux informatiques, passant ainsi des connaissances théoriques à une application pratique dans un environnement de terminal.

Vous commencerez par convertir des adresses IP de la notation décimale pointée familière à leur forme binaire sur 32 bits et vice versa. Le laboratoire vous guidera ensuite dans la traduction des masques de sous-réseau CIDR en leurs équivalents binaires et décimaux pointés. Enfin, vous appliquerez ces compétences pour identifier les portions réseau et hôte d'une adresse IP donnée et calculer le nombre total d'hôtes utilisables et de sous-réseaux disponibles dans un bloc CIDR spécifique.

Effectuer des conversions d'adresses IP et de masques de sous-réseau en Python

Dans cette étape, vous utiliserez l'interpréteur interactif Python pour effectuer plusieurs conversions réseau clés. Vous apprendrez à convertir des adresses IP entre les formats décimal pointé et binaire, et à traduire les masques de sous-réseau CIDR en leurs représentations binaires complètes et décimales pointées. Tout cela sera effectué en une seule session continue pour rationaliser le processus.

Une adresse IPv4 est un nombre de 32 bits. Pour la rendre lisible par les humains, elle est représentée par quatre nombres de 8 bits, appelés octets, séparés par des points (par exemple, 192.168.1.10). Chacun de ces octets peut être converti en un nombre binaire de 8 bits.

Tout d'abord, ouvrons le terminal et démarrons l'interpréteur interactif Python. L'environnement LabEx dispose de Python préinstallé. Tapez python3 et appuyez sur Entrée.
```
python3
```
Vous verrez une nouvelle invite, >>>, qui indique que vous êtes maintenant dans l'interpréteur Python.
```
Python 3.10.x (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

Convertir une adresse IP du décimal pointé en binaire

Pratiquons la conversion d'un seul nombre décimal en sa forme binaire. Nous utiliserons la fonction intégrée bin() de Python. Par exemple, pour convertir le nombre 192, tapez ce qui suit à l'invite Python :
```
bin(192)
```
Python renverra la représentation binaire, précédée de 0b pour indiquer qu'il s'agit d'un nombre binaire.
```
'0b11000000'
```
L'équivalent binaire de 192 est 11000000.
Maintenant, appliquons cela à une adresse IP complète, par exemple, 192.168.1.10. Nous devons convertir chaque octet (192, 168, 1 et 10) individuellement. Une règle essentielle dans l'adressage IP est que chaque octet doit être représenté par exactement 8 bits. Si un nombre binaire a moins de 8 bits, vous devez ajouter des zéros en tête pour le compléter.

Convertissons chaque partie :
- Pour 192 : bin(192) donne '0b11000000'. C'est déjà 8 bits : 11000000.
- Pour 168 : bin(168) donne '0b10101000'. C'est aussi 8 bits : 10101000.
- Pour 1 : bin(1) donne '0b1'. Nous devons le compléter à 8 bits : 00000001.
- Pour 10 : bin(10) donne '0b1010'. Nous devons le compléter à 8 bits : 00001010.
En combinant ceux-ci, vous obtenez la représentation binaire complète de 32 bits de l'adresse IP 192.168.1.10 :

11000000.10101000.00000001.00001010

Convertir une adresse IP binaire en décimal pointé

Nous allons maintenant effectuer l'opération inverse. Pour convertir un nombre binaire en décimal, nous utiliserons la fonction int() de Python. Cette fonction peut prendre deux arguments : le premier est le nombre sous forme de chaîne de caractères, et le second est la base de ce nombre. Comme nous convertissons à partir du binaire (base 2), nous utiliserons toujours 2 comme deuxième argument.

Essayons de convertir un seul octet binaire, 10101000, en décimal.
```
int('10101000', 2)
```
Python exécutera la conversion et affichera le résultat décimal.
```
168
```
Maintenant, convertissons l'adresse IP binaire complète de 32 bits de l'étape précédente : 11000000.10101000.00000001.00001010. Vous devrez convertir chaque octet de 8 bits un par un.
- Convertissez le premier octet : int('11000000', 2) ce qui donne 192.
- Convertissez le deuxième octet : int('10101000', 2) ce qui donne 168.
- Convertissez le troisième octet : int('00000001', 2) ce qui donne 1.
- Convertissez le quatrième octet : int('00001010', 2) ce qui donne 10.
En combinant ces résultats avec des points, vous obtenez l'adresse IP décimale pointée d'origine : 192.168.1.10. Cela confirme que vos conversions dans les deux sens sont correctes.

Traduire un masque de sous-réseau CIDR en sa forme binaire et décimale pointée

Un masque de sous-réseau est un nombre de 32 bits qui distingue la partie réseau d'une adresse IP de la partie hôte. La notation CIDR (Classless Inter-Domain Routing) est une manière abrégée de représenter un masque de sous-réseau.

Par exemple, une notation CIDR de /24 signifie que les 24 premiers bits du masque de sous-réseau de 32 bits sont des 1, et les bits restants sont des 0.

Déterminons la représentation binaire et décimale pointée pour un masque de sous-réseau /24.
- Binaire : Un masque /24 a 24 1 consécutifs suivis de 32 - 24 = 8 0. Lorsqu'il est divisé en octets, il se présente comme suit : 11111111.11111111.11111111.00000000
Maintenant, convertissons ce masque binaire en sa forme décimale pointée. Le premier octet est entièrement composé de 1, soit 11111111.
```
int('11111111', 2)
```
La sortie sera 255. Le dernier octet est entièrement composé de zéros, 00000000.
```
int('00000000', 2)
```
La sortie sera 0. Par conséquent, un masque de sous-réseau /24 est 255.255.255.0 en notation décimale pointée.
Essayons un exemple plus complexe, comme /26.
- Binaire : Un masque /26 a 26 1 suivis de 32 - 26 = 6 0. 11111111.11111111.11111111.11000000
- Les trois premiers octets sont entièrement composés de 1, ce que nous savons être 255. Convertissons le dernier octet, 11000000, en décimal.
```
int('11000000', 2)
```
La sortie sera 192. Ainsi, un masque de sous-réseau /26 est 255.255.255.192 en notation décimale pointée.
Une fois que vous avez terminé les conversions, vous pouvez quitter l'interpréteur Python et revenir à l'invite du terminal normal en tapant exit() et en appuyant sur Entrée.
```
exit()
```

Vous avez maintenant maîtrisé la conversion bidirectionnelle entre les adresses IP décimales pointées et binaires, ainsi que les masques de sous-réseau CIDR, une compétence cruciale pour tout professionnel du réseau.

Identifier les portions réseau et hôte d'une adresse IP

Dans cette étape, vous appliquerez vos connaissances des masques de sous-réseau pour identifier les portions réseau et hôte d'une adresse IP donnée. La fonction principale d'un masque de sous-réseau est d'indiquer à un ordinateur quelle partie d'une adresse IP identifie le réseau et quelle partie identifie le périphérique spécifique (hôte) sur ce réseau.

Ceci est réalisé par une opération logique AND bit à bit. L'ordinateur prend l'adresse IP (en binaire) et le masque de sous-réseau (en binaire) et effectue une opération AND sur ceux-ci. Le résultat est l'Adresse Réseau.

Les règles pour un AND bit à bit sont simples :

1 ET 1 = 1
1 ET 0 = 0
0 ET 1 = 0
0 ET 0 = 0

Essentiellement, le résultat est 1 uniquement si les deux bits correspondants sont 1.

Utilisons un exemple pratique pour voir cela en action. Nous allons déterminer l'adresse réseau pour l'adresse IP 192.168.1.74 avec un masque de sous-réseau /26 (255.255.255.192). Au lieu de le faire manuellement dans l'interpréteur, nous allons écrire un petit script Python pour effectuer le calcul.

Tout d'abord, créez un nouveau fichier de script Python nommé network_calc.py dans votre répertoire de projet en utilisant l'éditeur nano.
```
nano ~/project/network_calc.py
```

À l'intérieur de l'éditeur nano, copiez et collez le code Python suivant. Ce script définit l'IP et le masque, effectue l'opération AND sur chaque octet et affiche le résultat.

## Define the IP address and subnet mask octets
ip = [192, 168, 1, 74]
mask = [255, 255, 255, 192]

## Calculate the network address using a bitwise AND
network_addr = [ip[i] & mask[i] for i in range(4)]

## Format the output strings
ip_str = ".".join(map(str, ip))
network_str = ".".join(map(str, network_addr))

print(f"IP Address:      {ip_str}")
print(f"Subnet Mask:     /26 (255.255.255.192)")
print(f"Network Address: {network_str}")

Enregistrez le fichier et quittez nano en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X.
Maintenant, exécutez votre script depuis le terminal.
```
python3 ~/project/network_calc.py
```
Vous verrez la sortie suivante, qui montre clairement le résultat de l'opération AND :
```
IP Address:      192.168.1.74
Subnet Mask:     /26 (255.255.255.192)
Network Address: 192.168.1.64
```

À partir de cette sortie, nous pouvons identifier les différentes portions :

Portion Réseau : Le masque /26 indique que les 26 premiers bits constituent la portion réseau. L'Adresse Réseau calculée (192.168.1.64) est l'identifiant de ce réseau spécifique.
Portion Hôte : Les 32 - 26 = 6 bits restants constituent la portion hôte. Ces 6 bits identifient le périphérique spécifique (.74) au sein du réseau 192.168.1.64.

Vous avez réussi à utiliser un script pour trouver l'adresse réseau et pouvez désormais distinguer conceptuellement les portions réseau et hôte d'une adresse IP.

Calculer les hôtes utilisables et les sous-réseaux pour un CIDR donné

Dans cette dernière étape, vous apprendrez à effectuer deux calculs essentiels de sous-réseautage : déterminer le nombre d'adresses IP d'hôtes utilisables au sein d'un sous-réseau et découvrir combien de sous-réseaux peuvent être créés à partir d'un bloc réseau plus large. Ces calculs sont fondamentaux pour la planification et la conception de réseaux.

Voici les formules clés :

Nombre d'hôtes utilisables : La formule est 2^n - 2, où n est le nombre de bits d'hôte (les 0 dans le masque de sous-réseau). Nous soustrayons 2 car la première adresse d'un sous-réseau (où tous les bits d'hôte sont 0) est réservée en tant qu'Adresse Réseau, et la dernière adresse (où tous les bits d'hôte sont 1) est réservée en tant qu'Adresse de Diffusion (Broadcast Address). Aucune des deux ne peut être attribuée à un périphérique.
Nombre de sous-réseaux : Ceci est calculé lorsque vous divisez un réseau plus grand (par exemple, un /24) en plus petits (par exemple, /26). La formule est 2^m, où m est le nombre de bits que vous avez "empruntés" à la portion hôte d'origine pour créer le nouveau masque de sous-réseau plus spécifique.

Améliorons notre script network_calc.py pour effectuer ces calculs pour nous.

Tout d'abord, ouvrez à nouveau le fichier network_calc.py en utilisant l'éditeur nano.
```
nano ~/project/network_calc.py
```

Supprimez le contenu existant et remplacez-le par le code Python suivant. Cette nouvelle version se concentre sur le calcul du nombre d'hôtes et de sous-réseaux basé sur un préfixe CIDR donné.

## Define the CIDR prefix and the base network prefix
cidr_prefix = 26
base_prefix = 24 ## The original network we are subnetting from (e.g., a /24)

## --- Calculations ---

## 1. Calculate host bits
host_bits = 32 - cidr_prefix

## 2. Calculate usable hosts
## The ** operator is for exponentiation (power of)
if host_bits > 0:
    total_hosts = 2**host_bits
    usable_hosts = total_hosts - 2
else:
    total_hosts = 1
    usable_hosts = 1 ## For /31 and /32, rules are different, but we simplify here

## 3. Calculate subnet bits borrowed
subnet_bits = cidr_prefix - base_prefix

## 4. Calculate number of subnets
if subnet_bits >= 0:
    num_subnets = 2**subnet_bits
else:
    num_subnets = "N/A (Prefix is smaller than base)"


## --- Output ---
print(f"--- Subnet Calculations for a /{cidr_prefix} Network ---")
print(f"Host Bits: {host_bits}")
print(f"Total Hosts per Subnet: 2^{host_bits} = {total_hosts}")
print(f"Usable Hosts per Subnet: {total_hosts} - 2 = {usable_hosts}")
print("") ## Adds a blank line for readability
print(f"--- Subnetting from a /{base_prefix} Network ---")
print(f"Subnet Bits Borrowed: {subnet_bits}")
print(f"Number of Subnets Created: 2^{subnet_bits} = {num_subnets}")

Enregistrez le fichier et quittez nano en appuyant sur Ctrl+O, Entrée, puis Ctrl+X.
Exécutez le script mis à jour depuis votre terminal.
```
python3 ~/project/network_calc.py
```

Le script affichera maintenant les valeurs calculées :

--- Subnet Calculations for a /26 Network ---
Host Bits: 6
Total Hosts per Subnet: 2^6 = 64
Usable Hosts per Subnet: 64 - 2 = 62

--- Subnetting from a /24 Network ---
Subnet Bits Borrowed: 2
Number of Subnets Created: 2^2 = 4

Cette sortie montre clairement que pour un réseau /26, il y a 6 bits d'hôte, ce qui permet 2^6 = 64 adresses au total. Après avoir réservé les adresses réseau et de diffusion, il vous reste 62 hôtes utilisables. Elle montre également que si vous avez commencé avec un réseau /24, vous avez emprunté 2 bits pour créer le masque /26, ce qui donne 2^2 = 4 sous-réseaux possibles.

Résumé

Dans ce laboratoire, vous avez appris à effectuer des calculs fondamentaux d'adresses IP et de sous-réseautage directement dans le terminal Linux. Vous avez utilisé l'interpréteur interactif Python comme un outil puissant pour convertir les adresses IP du format décimal pointé lisible par l'homme en leur équivalent binaire sur 32 bits, puis inversement. Cela incluait la conversion de chaque octet individuellement et l'assurance d'un remplissage correct de 8 bits. Vous vous êtes également exercé à traduire la notation de masque de sous-réseau CIDR en ses formes binaires et décimales pointées complètes.

En vous appuyant sur ces compétences de conversion, vous les avez appliquées à des tâches d'analyse réseau essentielles. Vous avez appris à distinguer les portions réseau et hôte d'une adresse IP en utilisant le masque de sous-réseau. Enfin, vous avez effectué les calculs nécessaires pour déterminer le nombre d'adresses d'hôtes utilisables et le nombre total de sous-réseaux disponibles pour un réseau en fonction de son préfixe CIDR donné, consolidant ainsi votre compréhension des principes de sous-réseautage IP.

Effectuer le sous-réseautage IP et la conversion binaire dans le terminal Linux