# [LIVRE] Cours Complet sur l'Adressage IP et le Réseau

## Table des matières

1. [Introduction aux réseaux](#introduction)
2. [Adressage IP](#adressage)
3. [Calculs pratiques](#calculs)
4. [Routage de base](#routage)
5. [Configuration réseau](#configuration)
6. [Exercices pratiques détaillés](#exercices)

---

## [WEB] 1. Introduction aux réseaux <a name="introduction"></a>

### Qu'est-ce qu'une adresse IP ?

Une **adresse IP** (Internet Protocol) est comme une adresse postale pour votre ordinateur. Elle permet d'identifier de manière unique chaque appareil sur un réseau.

**Format** : Une adresse IPv4 est composée de 4 nombres (octets) séparés par des points.
- Exemple : `192.168.1.10`
- Chaque nombre va de **0 à 255**

### Pourquoi 0 à 255 ?

Chaque octet est codé sur **8 bits** (8 chiffres binaires : 0 ou 1)
- Le plus petit : `00000000` = 0
- Le plus grand : `11111111` = 255

---

## - 2. Adressage IP <a name="adressage"></a>

### 2.1 Les composants d'une adresse IP

Chaque adresse IP contient **deux parties** :
1. **Partie réseau** : Identifie le réseau
2. **Partie hôte** : Identifie l'appareil dans ce réseau

**Analogie** : 
- Partie réseau = Nom de la rue
- Partie hôte = Numéro de la maison

### 2.2 Le masque de sous-réseau

Le **masque de sous-réseau** indique quelle partie de l'adresse est le réseau et quelle partie est l'hôte.

**Exemples courants** :
```
255.255.255.0   -> Les 3 premiers octets = réseau, le dernier = hôte
255.255.0.0     -> Les 2 premiers octets = réseau, les 2 derniers = hôte
255.0.0.0       -> Le 1er octet = réseau, les 3 derniers = hôte
```

**En binaire** :
```
255.255.255.0 = 11111111.11111111.11111111.00000000
                ^ Les 1 = partie réseau
                ^ Les 0 = partie hôte
```

### 2.3 Notation CIDR (Slash notation)

La notation CIDR est une façon simplifiée d'écrire le masque.

**Format** : `Adresse_IP/nombre_de_bits_réseau`

**Exemples** :
```
192.168.1.0/24  -> Masque = 255.255.255.0 (24 bits à 1)
10.0.0.0/8      -> Masque = 255.0.0.0 (8 bits à 1)
172.16.0.0/16   -> Masque = 255.255.0.0 (16 bits à 1)
192.168.1.0/25  -> Masque = 255.255.255.128 (25 bits à 1)
```

**Tableau de conversion CIDR** :

| CIDR | Masque | Nombre d'hôtes possibles |
|------|--------|-------------------------|
| /24 | 255.255.255.0 | 254 hôtes |
| /25 | 255.255.255.128 | 126 hôtes |
| /26 | 255.255.255.192 | 62 hôtes |
| /27 | 255.255.255.224 | 30 hôtes |
| /28 | 255.255.255.240 | 14 hôtes |
| /16 | 255.255.0.0 | 65,534 hôtes |
| /8 | 255.0.0.0 | 16,777,214 hôtes |

### 2.4 Adresse réseau

L'**adresse réseau** identifie le réseau entier. C'est toujours la **première adresse** de la plage.

**Caractéristique** : Tous les bits de la partie hôte sont à **0**.

**Exemple** :
```
IP : 192.168.1.50/24
Masque : 255.255.255.0
Adresse réseau : 192.168.1.0
```

### 2.5 Adresse de broadcast

L'**adresse de broadcast** permet d'envoyer un message à **tous les appareils** du réseau. C'est toujours la **dernière adresse** de la plage.

**Caractéristique** : Tous les bits de la partie hôte sont à **1**.

**Exemple** :
```
IP : 192.168.1.50/24
Masque : 255.255.255.0
Adresse de broadcast : 192.168.1.255
```

### 2.6 Adresses hôtes utilisables

Les adresses entre l'adresse réseau et le broadcast peuvent être attribuées aux appareils.

**Exemple avec /24** :
```
Réseau : 192.168.1.0
Première IP utilisable : 192.168.1.1
Dernière IP utilisable : 192.168.1.254
Broadcast : 192.168.1.255
Total : 254 adresses utilisables
```

---

## - 3. Calculs pratiques <a name="calculs"></a>

### 3.1 Méthode pour trouver l'adresse réseau

**Étape 1** : Convertir l'IP et le masque en binaire
**Étape 2** : Faire un ET logique (AND) bit à bit
**Étape 3** : Reconvertir en décimal

**Exemple détaillé** :

```
IP : 192.168.1.130
Masque : 255.255.255.128 (/25)

Étape 1 - Conversion en binaire :
IP :     11000000.10101000.00000001.10000010
Masque : 11111111.11111111.11111111.10000000

Étape 2 - ET logique (AND) :
         11000000.10101000.00000001.10000010  (IP)
    AND  11111111.11111111.11111111.10000000  (Masque)
    =    11000000.10101000.00000001.10000000

Étape 3 - Reconversion :
Réseau : 192.168.1.128
```

**Méthode simplifiée pour /24, /16, /8** :

- **/24** : Copier les 3 premiers octets, mettre 0 au dernier
  - 192.168.1.50/24 -> Réseau : 192.168.1.0

- **/16** : Copier les 2 premiers octets, mettre 0 aux 2 derniers
  - 172.16.45.78/16 -> Réseau : 172.16.0.0

- **/8** : Copier le 1er octet, mettre 0 aux 3 derniers
  - 10.50.100.200/8 -> Réseau : 10.0.0.0

### 3.2 Méthode pour trouver le broadcast

**Formule** : Adresse réseau + (tous les bits hôtes à 1)

**Méthode pratique** :

1. Trouver l'adresse réseau
2. Identifier la partie hôte
3. Mettre tous les bits hôtes à 1

**Exemple avec /25** :

```
IP : 192.168.1.130/25
Masque : 255.255.255.128

Réseau : 192.168.1.128

Le masque 255.255.255.128 en binaire :
11111111.11111111.11111111.10000000
                            ^ 7 bits pour les hôtes

Adresse réseau : 192.168.1.128 = ...10000000
Broadcast :      192.168.1.255 = ...11111111

Broadcast : 192.168.1.255
```

**Méthode rapide pour /24** :
- Réseau : 192.168.1.0
- Broadcast : 192.168.1.255 (remplacer le dernier octet par 255)

### 3.3 Trouver la plage d'IP utilisables

**Formule** :
```
Première IP utilisable = Adresse réseau + 1
Dernière IP utilisable = Adresse de broadcast - 1
```

**Exemple complet** :

```
IP donnée : 10.50.25.75/16

1. Adresse réseau : 10.50.0.0
2. Broadcast : 10.50.255.255
3. Première IP utilisable : 10.50.0.1
4. Dernière IP utilisable : 10.50.255.254
5. Nombre d'hôtes : 65,534
```

### 3.4 Calculer le nombre d'hôtes

**Formule** : 2^(nombre de bits hôtes) - 2

Le **-2** correspond à :
- 1 pour l'adresse réseau
- 1 pour l'adresse de broadcast

**Exemples** :

```
/24 : 32 - 24 = 8 bits pour les hôtes
      2^8 - 2 = 256 - 2 = 254 hôtes

/25 : 32 - 25 = 7 bits pour les hôtes
      2^7 - 2 = 128 - 2 = 126 hôtes

/26 : 32 - 26 = 6 bits pour les hôtes
      2^6 - 2 = 64 - 2 = 62 hôtes

/16 : 32 - 16 = 16 bits pour les hôtes
      2^16 - 2 = 65,536 - 2 = 65,534 hôtes
```

### 3.5 Vérifier si deux IP sont dans le même réseau

**Méthode** : Calculer l'adresse réseau pour chaque IP. Si elles sont identiques, les IP sont dans le même réseau.

**Exemple 1 - Même réseau** :

```
IP 1 : 192.168.1.50/24
IP 2 : 192.168.1.200/24

Réseau de IP1 : 192.168.1.0
Réseau de IP2 : 192.168.1.0

Conclusion : OUI, elles sont dans le même réseau
```

**Exemple 2 - Réseaux différents** :

```
IP 1 : 192.168.1.50/24
IP 2 : 192.168.2.50/24

Réseau de IP1 : 192.168.1.0
Réseau de IP2 : 192.168.2.0

Conclusion : NON, elles sont dans des réseaux différents
```

**Exemple 3 - Masques différents** :

```
IP 1 : 192.168.1.50/25
IP 2 : 192.168.1.200/25

Réseau de IP1 : 192.168.1.0
Réseau de IP2 : 192.168.1.128

Conclusion : NON, elles sont dans des réseaux différents
```

---

## - 4. Routage de base <a name="routage"></a>

### 4.1 Qu'est-ce que le routage ?

Le **routage** est le processus qui permet d'acheminer les données d'un réseau à un autre.

**Analogie** : Si vous voulez envoyer une lettre :
- Dans votre quartier -> Vous la déposez directement
- Dans une autre ville -> Vous utilisez la poste (routeur)

### 4.2 La passerelle par défaut (Default Gateway)

La **passerelle par défaut** est l'adresse du routeur qui permet de sortir de votre réseau local.

**Règle** : Généralement, c'est la **première IP utilisable** du réseau.

**Exemples** :

```
Réseau : 192.168.1.0/24
Passerelle typique : 192.168.1.1

Réseau : 10.0.0.0/8
Passerelle typique : 10.0.0.1

Réseau : 172.16.50.0/24
Passerelle typique : 172.16.50.1
```

### 4.3 Table de routage

La **table de routage** indique à l'ordinateur où envoyer les paquets.

**Exemple de table de routage** :

```
Destination      Passerelle       Interface
192.168.1.0/24   0.0.0.0          eth0      <- Réseau local direct
0.0.0.0/0        192.168.1.1      eth0      <- Route par défaut
```

**Interprétation** :
- Ligne 1 : Pour joindre 192.168.1.0/24, envoyer directement (réseau local)
- Ligne 2 : Pour tout le reste (Internet), envoyer via 192.168.1.1

### 4.4 La route par défaut (0.0.0.0/0)

**0.0.0.0/0** signifie "**toutes les destinations**" (route par défaut).

**Fonctionnement** :
1. L'ordinateur cherche une route spécifique
2. Si aucune route spécifique n'existe -> Utilise 0.0.0.0/0
3. Envoie le paquet à la passerelle par défaut

**Exemple pratique** :

```
Je veux joindre 8.8.8.8 (DNS Google)

Ma table de routage :
192.168.1.0/24   ->   Direct
0.0.0.0/0        ->   192.168.1.1

8.8.8.8 n'est pas dans 192.168.1.0/24
-> J'utilise la route par défaut
-> J'envoie le paquet à 192.168.1.1
```

### 4.5 Exemple de communication entre réseaux

**Scénario** :

```
PC A : 192.168.1.10/24 (Passerelle : 192.168.1.1)
PC B : 192.168.2.20/24 (Passerelle : 192.168.2.1)
```

**Processus** :

1. PC A veut contacter PC B (192.168.2.20)
2. PC A calcule : "192.168.2.20 n'est pas dans mon réseau (192.168.1.0/24)"
3. PC A envoie le paquet à sa passerelle (192.168.1.1)
4. Le routeur reçoit le paquet et le transmet vers 192.168.2.0/24
5. PC B reçoit le paquet

---

## - 5. Configuration réseau <a name="configuration"></a>

### 5.1 Configuration IP manuelle (Linux)

**Méthode temporaire** (perdue au redémarrage) :

```bash
# Assigner une adresse IP
sudo ip addr add 192.168.1.100/24 dev eth0

# Activer l'interface
sudo ip link set eth0 up

# Ajouter la passerelle par défaut
sudo ip route add default via 192.168.1.1
```

**Exemple complet** :

```bash
# Configuration : 192.168.1.50/24, Passerelle : 192.168.1.1

sudo ip addr flush dev eth0                      # Nettoyer l'interface
sudo ip addr add 192.168.1.50/24 dev eth0        # Ajouter l'IP
sudo ip link set eth0 up                         # Activer l'interface
sudo ip route add default via 192.168.1.1        # Ajouter la passerelle
```

### 5.2 Configuration permanente (Netplan - Ubuntu)

**Fichier** : `/etc/netplan/01-network-config.yaml`

```yaml
network:
  version: 2
  ethernets:
    eth0:
      addresses:
        - 192.168.1.100/24
      routes:
        - to: 0.0.0.0/0
          via: 192.168.1.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
```

**Appliquer la configuration** :

```bash
sudo netplan apply
```

### 5.3 Configuration DHCP

**DHCP** (Dynamic Host Configuration Protocol) attribue automatiquement :
- Adresse IP
- Masque de sous-réseau
- Passerelle par défaut
- Serveurs DNS

**Avantages** :
- [OK] Pas de configuration manuelle
- [OK] Évite les conflits d'IP
- [OK] Facile à gérer pour de nombreux appareils

**Configuration DHCP (Netplan)** :

```yaml
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: true
```

**Méthode temporaire** :

```bash
sudo dhclient eth0
```

### 5.4 Vérification de la configuration

**Commande `ip addr`** (ou `ip a`) :

```bash
ip addr show eth0
```

**Sortie exemple** :

```
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500
    inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0
       valid_lft forever preferred_lft forever
```

**Informations** :
- `192.168.1.100/24` : Adresse IP et masque
- `brd 192.168.1.255` : Adresse de broadcast

**Commande `ip route`** :

```bash
ip route show
```

**Sortie exemple** :

```
default via 192.168.1.1 dev eth0 
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.100
```

**Informations** :
- Ligne 1 : Route par défaut via 192.168.1.1
- Ligne 2 : Réseau local directement accessible

**Tester la connectivité** :

```bash
# Tester la passerelle
ping -c 4 192.168.1.1

# Tester Internet
ping -c 4 8.8.8.8

# Tester la résolution DNS
ping -c 4 google.com
```

---

## - 6. Exercices pratiques détaillés <a name="exercices"></a>

### Exercice 1 : Adressage de base (/24)

**Énoncé** : Vous avez l'adresse IP suivante : `192.168.10.45/24`

**Questions** :
1. Quelle est l'adresse réseau ?
2. Quelle est l'adresse de broadcast ?
3. Quelle est la plage d'IP utilisables ?
4. Combien d'hôtes peuvent être connectés ?

**Solution détaillée** :

```
IP : 192.168.10.45/24
Masque : 255.255.255.0

1. Adresse réseau :
   Méthode : Les 3 premiers octets restent, le dernier devient 0
   Réponse : 192.168.10.0

2. Adresse de broadcast :
   Méthode : Les 3 premiers octets restent, le dernier devient 255
   Réponse : 192.168.10.255

3. Plage d'IP utilisables :
   Première : 192.168.10.0 + 1 = 192.168.10.1
   Dernière : 192.168.10.255 - 1 = 192.168.10.254
   Réponse : 192.168.10.1 à 192.168.10.254

4. Nombre d'hôtes :
   Calcul : 2^8 - 2 = 256 - 2 = 254
   Réponse : 254 hôtes
```

### Exercice 2 : Sous-réseau plus complexe (/26)

**Énoncé** : IP : `172.16.50.100/26`

**Questions** :
1. Convertir le masque /26 en notation décimale
2. Quelle est l'adresse réseau ?
3. Quelle est l'adresse de broadcast ?
4. Combien d'hôtes ?

**Solution détaillée** :

```
IP : 172.16.50.100/26

1. Conversion du masque /26 :
   /26 signifie 26 bits à 1
   
   En binaire :
   11111111.11111111.11111111.11000000
   
   En décimal :
   255.255.255.192

2. Adresse réseau :
   
   Méthode binaire :
   100 en binaire = 01100100
   Masque dernier octet = 11000000
   
   01100100 (100)
   11000000 (192)
   --------  AND
   01000000 = 64
   
   Adresse réseau : 172.16.50.64

3. Adresse de broadcast :
   
   Réseau : 172.16.50.64
   Nombre de bits hôtes : 32 - 26 = 6 bits
   Nombre d'adresses : 2^6 = 64
   
   Broadcast : 64 + 64 - 1 = 127
   
   Adresse broadcast : 172.16.50.127

4. Nombre d'hôtes :
   2^6 - 2 = 64 - 2 = 62 hôtes
   
   Plage utilisable : 172.16.50.65 à 172.16.50.126
```

### Exercice 3 : Même réseau ou pas ?

**Énoncé** : Déterminer si les paires d'IP suivantes sont dans le même réseau.

**Paire A** :
- IP1 : 10.5.20.50/16
- IP2 : 10.5.100.200/16

**Paire B** :
- IP1 : 192.168.1.50/25
- IP2 : 192.168.1.150/25

**Solution détaillée** :

```
PAIRE A :

IP1 : 10.5.20.50/16
Masque : 255.255.0.0
Réseau IP1 : 10.5.0.0 (les 2 premiers octets restent)

IP2 : 10.5.100.200/16
Masque : 255.255.0.0
Réseau IP2 : 10.5.0.0

Réseau IP1 = Réseau IP2
Réponse : OUI, elles sont dans le même réseau

---

PAIRE B :

IP1 : 192.168.1.50/25
Masque : 255.255.255.128

En binaire pour le dernier octet :
50 = 00110010
128 = 10000000 (masque)
     --------  AND
     00000000 = 0

Réseau IP1 : 192.168.1.0

IP2 : 192.168.1.150/25
150 = 10010110
128 = 10000000 (masque)
      --------  AND
      10000000 = 128

Réseau IP2 : 192.168.1.128

Réseau IP1 ≠ Réseau IP2
Réponse : NON, elles sont dans des réseaux différents

Détail : Il y a 2 sous-réseaux /25 dans le réseau /24 :
- 192.168.1.0/25 (0 à 127)
- 192.168.1.128/25 (128 à 255)
```

### Exercice 4 : Subdivision en sous-réseaux

**Énoncé** : Vous devez diviser le réseau `192.168.100.0/24` en **4 sous-réseaux** égaux.

**Questions** :
1. Quel nouveau masque utiliser ?
2. Lister les 4 sous-réseaux avec leurs plages

**Solution détaillée** :

```
Réseau de départ : 192.168.100.0/24

1. Calcul du nouveau masque :
   
   Pour 4 sous-réseaux, il faut 2 bits supplémentaires
   (car 2^2 = 4)
   
   Nouveau masque : /24 + 2 = /26
   En décimal : 255.255.255.192
   
   Nombre d'hôtes par sous-réseau : 2^6 - 2 = 62 hôtes

2. Les 4 sous-réseaux :

   SOUS-RÉSEAU 1 :
   Réseau : 192.168.100.0/26
   Plage : 192.168.100.1 à 192.168.100.62
   Broadcast : 192.168.100.63
   
   SOUS-RÉSEAU 2 :
   Réseau : 192.168.100.64/26
   Plage : 192.168.100.65 à 192.168.100.126
   Broadcast : 192.168.100.127
   
   SOUS-RÉSEAU 3 :
   Réseau : 192.168.100.128/26
   Plage : 192.168.100.129 à 192.168.100.190
   Broadcast : 192.168.100.191
   
   SOUS-RÉSEAU 4 :
   Réseau : 192.168.100.192/26
   Plage : 192.168.100.193 à 192.168.100.254
   Broadcast : 192.168.100.255

Calcul du "saut" entre sous-réseaux :
256 / 4 = 64
Donc chaque sous-réseau commence à : 0, 64, 128, 192
```

### Exercice 5 : Configuration complète

**Énoncé** : Vous devez configurer un PC avec les informations suivantes :
- IP : 10.20.30.55/24
- Passerelle : 10.20.30.1
- DNS : 8.8.8.8

**Questions** :
1. Écrire les commandes pour configuration temporaire
2. Écrire le fichier Netplan pour configuration permanente
3. Donner les commandes de vérification

**Solution détaillée** :

```
1. Configuration temporaire :

# Supprimer la configuration existante
sudo ip addr flush dev eth0

# Ajouter l'adresse IP
sudo ip addr add 10.20.30.55/24 dev eth0

# Activer l'interface
sudo ip link set eth0 up

# Ajouter la passerelle par défaut
sudo ip route add default via 10.20.30.1 dev eth0

# Configurer le DNS (éditer /etc/resolv.conf)
echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

---

2. Configuration permanente (Netplan) :

Fichier : /etc/netplan/01-netcfg.yaml

network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      addresses:
        - 10.20.30.55/24
      routes:
        - to: 0.0.0.0/0
          via: 10.20.30.1
      nameservers:
        addresses:
          - 8.8.8.8

# Appliquer
sudo netplan apply

---

3. Vérification :

# Vérifier l'IP
ip addr show eth0
# Résultat attendu : inet 10.20.30.55/24

# Vérifier la route
ip route show
# Résultat attendu : 
#   default via 10.20.30.1 dev eth0
#   10.20.30.0/24 dev eth0

# Tester la passerelle
ping -c 4 10.20.30.1

# Tester Internet
ping -c 4 8.8.8.8

# Tester le DNS
ping -c 4 google.com
```

### Exercice 6 : Dépannage réseau

**Énoncé** : Un PC (192.168.15.100/24) ne peut pas accéder à Internet. Sa passerelle est 192.168.15.1.

**Questions de diagnostic** :
1. Vérifier la configuration IP
2. Tester la connectivité locale
3. Tester la passerelle
4. Tester Internet

**Solution détaillée** :

```
DIAGNOSTIC ÉTAPE PAR ÉTAPE :

1. Vérifier la configuration IP :

$ ip addr show
# Vérifier :
# - L'interface est UP
# - L'adresse IP est correcte : 192.168.15.100/24
# - Le broadcast est correct : 192.168.15.255

2. Vérifier la table de routage :

$ ip route show
# Doit contenir :
# - default via 192.168.15.1 dev eth0
# - 192.168.15.0/24 dev eth0

Si la route par défaut manque :
$ sudo ip route add default via 192.168.15.1

3. Tester la connectivité locale :

# Tester un autre PC du même réseau (ex: 192.168.15.50)
$ ping -c 4 192.168.15.50

Si ça ne marche pas :
-> Problème de câble ou de switch
-> Vérifier : ip link show eth0 (doit être UP)

4. Tester la passerelle :

$ ping -c 4 192.168.15.1

Si ça ne marche pas :
-> La passerelle est inaccessible
-> Vérifier que la passerelle est correcte
-> Vérifier le câblage

5. Tester Internet par IP :

$ ping -c 4 8.8.8.8

Si ça ne marche pas :
-> Problème de routage au niveau du routeur
-> Le routeur n'a pas accès à Internet

6. Tester la résolution DNS :

$ ping -c 4 google.com

Si 8.8.8.8 marche mais pas google.com :
-> Problème DNS
-> Vérifier : cat /etc/resolv.conf
-> Ajouter : nameserver 8.8.8.8

RÉSUMÉ DU DIAGNOSTIC :

[OK] Configuration IP    -> ip addr
[OK] Table de routage    -> ip route
[OK] Réseau local        -> ping IP_locale
[OK] Passerelle          -> ping passerelle
[OK] Internet (IP)       -> ping 8.8.8.8
[OK] DNS                 -> ping google.com
```

### Exercice 7 : Masques personnalisés

**Énoncé** : Calculer les informations pour `172.20.45.67/27`

**Questions** :
1. Masque en notation décimale
2. Adresse réseau
3. Broadcast
4. Plage utilisable
5. Nombre d'hôtes

**Solution détaillée** :

```
IP : 172.20.45.67/27

1. Masque en notation décimale :
   
   /27 = 27 bits à 1
   En binaire : 11111111.11111111.11111111.11100000
   
   Dernier octet : 11100000
   128 + 64 + 32 = 224
   
   Masque : 255.255.255.224

2. Adresse réseau :
   
   IP dernier octet : 67
   67 en binaire : 01000011
   
   Masque : 11100000
   
   01000011 (67)
   11100000 (224)
   --------  AND
   01000000 = 64
   
   Adresse réseau : 172.20.45.64

3. Broadcast :
   
   Bits pour les hôtes : 32 - 27 = 5 bits
   Nombre d'adresses : 2^5 = 32
   
   Réseau : 64
   Prochaine plage : 64 + 32 = 96
   Broadcast : 96 - 1 = 95
   
   Adresse broadcast : 172.20.45.95

4. Plage utilisable :
   
   Première : 172.20.45.64 + 1 = 172.20.45.65
   Dernière : 172.20.45.95 - 1 = 172.20.45.94
   
   Plage : 172.20.45.65 à 172.20.45.94

5. Nombre d'hôtes :
   
   2^5 - 2 = 32 - 2 = 30 hôtes
```

---

## [NOTE] Récapitulatif des formules essentielles

```
1. Nombre d'hôtes = 2^(bits hôtes) - 2

2. Adresse réseau = IP AND Masque

3. Broadcast = Adresse réseau + Nombre total d'adresses - 1

4. Première IP utilisable = Adresse réseau + 1

5. Dernière IP utilisable = Broadcast - 1

6. Conversion CIDR -> Décimal :
   /8  -> 255.0.0.0
   /16 -> 255.255.0.0
   /24 -> 255.255.255.0
   /25 -> 255.255.255.128
   /26 -> 255.255.255.192
   /27 -> 255.255.255.224
   /28 -> 255.255.255.240
```

---

## [OBJECTIF] Conseils pour réussir

1. **Maîtriser le binaire** : C'est la base de tout
2. **Pratiquer régulièrement** : Faire des exercices quotidiens
3. **Visualiser** : Dessiner les réseaux et sous-réseaux
4. **Comprendre avant de mémoriser** : La logique avant les formules
5. **Utiliser des outils** : Calculateurs IP pour vérifier vos résultats

---

## [LIEN] Ressources supplémentaires

- Calculateur IP en ligne : https://www.subnet-calculator.com/
- Convertisseur binaire : https://www.rapidtables.com/convert/number/decimal-to-binary.html
- Documentation Netplan : https://netplan.io/examples

---

**Bonne pratique et n'hésitez pas à refaire les exercices plusieurs fois !** [RAPIDE]


# [OBJECTIF] Guide Complet des Calculs avec /25 et TOUS les cas possibles

## [DOCS] Table des matières
1. [Comprendre /25 en profondeur](#partie1)
2. [Tous les calculs possibles avec différentes inconnues](#partie2)
3. [Méthode universelle pour n'importe quel masque](#partie3)
4. [Exercices avec TOUTES les combinaisons possibles](#partie4)

---

## - PARTIE 1 : Comprendre /25 en profondeur <a name="partie1"></a>

### Qu'est-ce que /25 ?

```
/25 = 25 bits à 1 dans le masque

En binaire (32 bits total) :
11111111.11111111.11111111.1000000
                             ^
                             25ème bit

Bits réseau : 25
Bits hôtes : 32 - 25 = 7 bits
```

### Conversion /25 en notation décimale

```
Dernier octet : 10000000 (en binaire)

Calcul :
1×128 + 0×64 + 0×32 + 0×16 + 0×8 + 0×4 + 0×2 + 0×1 = 128

Masque complet : 255.255.255.128
```

### Caractéristiques d'un réseau /25

```
Nombre d'adresses totales : 2^7 = 128 adresses
Nombre d'hôtes utilisables : 128 - 2 = 126 hôtes

Dans un /24 (256 adresses), il y a 2 réseaux /25 :
- Premier /25 : 0 à 127
- Deuxième /25 : 128 à 255
```

---

## - PARTIE 2 : TOUS les calculs possibles <a name="partie2"></a>

### [LISTE] CAS 1 : On a l'IP -> Trouver tout le reste

**Donné :** IP = `192.168.1.100/25`

**À trouver :** Réseau, Broadcast, Plage utilisable

#### **MÉTHODE DÉTAILLÉE :**

```
ÉTAPE 1 : Identifier la plage du sous-réseau /25

Le masque /25 crée des blocs de 128 adresses
Plages possibles dans .1.X :
- Bloc 1 : 0 à 127
- Bloc 2 : 128 à 255

Notre IP : 192.168.1.100
100 est entre 0 et 127 -> Nous sommes dans le BLOC 1

ÉTAPE 2 : Trouver l'adresse réseau

Adresse réseau = Début du bloc = 192.168.1.0

ÉTAPE 3 : Trouver le broadcast

Broadcast = Fin du bloc = 192.168.1.127

ÉTAPE 4 : Plage utilisable

Première IP : 192.168.1.0 + 1 = 192.168.1.1
Dernière IP : 192.168.1.127 - 1 = 192.168.1.126

Plage utilisable : 192.168.1.1 à 192.168.1.126
```

#### **MÉTHODE RAPIDE (Formule) :**

```
Pour /25, bloc de 128 :

1. Diviser le dernier octet par 128
   100 ÷ 128 = 0 (quotient)
   
2. Réseau = Quotient × 128 = 0 × 128 = 0
   -> Adresse réseau : 192.168.1.0
   
3. Broadcast = Réseau + 128 - 1 = 0 + 127 = 127
   -> Broadcast : 192.168.1.127
```

---

### [LISTE] CAS 2 : On a le Broadcast -> Trouver le reste

**Donné :** Broadcast = `10.50.30.255/25`

**À trouver :** Réseau, IP utilisables

#### **MÉTHODE DÉTAILLÉE :**

```
ÉTAPE 1 : Comprendre la position

Broadcast = 10.50.30.255
C'est la DERNIÈRE adresse du bloc

ÉTAPE 2 : Trouver l'adresse réseau

Pour /25, taille du bloc = 128
Réseau = Broadcast - 128 + 1
Réseau = 255 - 128 + 1 = 128

Adresse réseau : 10.50.30.128

ÉTAPE 3 : Vérification

Bloc : 128 à 255 (128 adresses)
[OK] 255 est bien la fin du bloc

ÉTAPE 4 : Plage utilisable

Première IP : 10.50.30.128 + 1 = 10.50.30.129
Dernière IP : 10.50.30.255 - 1 = 10.50.30.254

Plage : 10.50.30.129 à 10.50.30.254
```

#### **FORMULE RAPIDE :**

```
Broadcast (dernier octet) = 255

Pour /25 :
Réseau = (Broadcast ÷ 128) × 128
       = (255 ÷ 128) × 128
       = 1 × 128
       = 128

Adresse réseau : 10.50.30.128
```

---

### [LISTE] CAS 3 : On a le Réseau -> Trouver le Broadcast

**Donné :** Réseau = `172.16.80.128/25`

**À trouver :** Broadcast, Plage utilisable

#### **MÉTHODE DÉTAILLÉE :**

```
ÉTAPE 1 : Identifier le début du bloc

Réseau = 172.16.80.128
C'est la PREMIÈRE adresse du bloc

ÉTAPE 2 : Calculer la taille du bloc

/25 -> 7 bits pour les hôtes
Taille = 2^7 = 128 adresses

ÉTAPE 3 : Trouver le broadcast

Broadcast = Réseau + Taille - 1
Broadcast = 128 + 128 - 1 = 255

Adresse broadcast : 172.16.80.255

ÉTAPE 4 : Plage utilisable

Première IP : 172.16.80.128 + 1 = 172.16.80.129
Dernière IP : 172.16.80.255 - 1 = 172.16.80.254

Plage : 172.16.80.129 à 172.16.80.254
```

---

### [LISTE] CAS 4 : On a DEUX IP -> Savoir si même réseau

**Donné :** 
- IP1 = `192.168.5.60/25`
- IP2 = `192.168.5.140/25`

**Question :** Sont-elles dans le même réseau ?

#### **MÉTHODE DÉTAILLÉE :**

```
ÉTAPE 1 : Trouver le réseau de IP1

IP1 = 192.168.5.60
60 ÷ 128 = 0
Réseau IP1 = 0 × 128 = 0
-> Réseau : 192.168.5.0

Bloc IP1 : 0 à 127

ÉTAPE 2 : Trouver le réseau de IP2

IP2 = 192.168.5.140
140 ÷ 128 = 1
Réseau IP2 = 1 × 128 = 128
-> Réseau : 192.168.5.128

Bloc IP2 : 128 à 255

ÉTAPE 3 : Comparaison

Réseau IP1 : 192.168.5.0
Réseau IP2 : 192.168.5.128

192.168.5.0 ≠ 192.168.5.128

RÉPONSE : NON, elles sont dans des réseaux DIFFÉRENTS
```

---

### [LISTE] CAS 5 : On a une IP dans une plage -> Trouver le masque

**Donné :** 
- Réseau : `192.168.10.0`
- Broadcast : `192.168.10.127`

**À trouver :** Le masque (notation CIDR)

#### **MÉTHODE DÉTAILLÉE :**

```
ÉTAPE 1 : Calculer le nombre d'adresses

Nombre d'adresses = Broadcast - Réseau + 1
                  = 127 - 0 + 1
                  = 128 adresses

ÉTAPE 2 : Trouver la puissance de 2

128 = 2^7
Donc 7 bits pour les hôtes

ÉTAPE 3 : Calculer le CIDR

CIDR = 32 - bits_hôtes
     = 32 - 7
     = /25

ÉTAPE 4 : Vérification

/25 -> Masque : 255.255.255.128
Taille du bloc : 128 [OK]
```

---

### [LISTE] CAS 6 : On a le nombre d'hôtes -> Trouver le masque

**Donné :** On veut 100 hôtes utilisables

**À trouver :** Quel masque utiliser ?

#### **MÉTHODE DÉTAILLÉE :**

```
ÉTAPE 1 : Ajouter 2 (réseau + broadcast)

Nombre d'adresses nécessaires = 100 + 2 = 102

ÉTAPE 2 : Trouver la puissance de 2 supérieure

2^6 = 64   (trop petit)
2^7 = 128  (suffisant) [OK]

Il faut 7 bits pour les hôtes

ÉTAPE 3 : Calculer le CIDR

CIDR = 32 - 7 = /25

RÉPONSE : Il faut utiliser un /25

Vérification :
/25 -> 2^7 - 2 = 126 hôtes (> 100) [OK]
```

---

## - PARTIE 3 : Méthode UNIVERSELLE pour N'IMPORTE QUEL masque <a name="partie3"></a>

### [OBJECTIF] Tableau de référence rapide

```
CIDR | Masque          | Taille bloc | Hôtes | Nombre de sous-réseaux dans /24
-----|-----------------|-------------|-------|--------------------------------
/24  | 255.255.255.0   | 256        | 254   | 1
/25  | 255.255.255.128 | 128        | 126   | 2
/26  | 255.255.255.192 | 64         | 62    | 4
/27  | 255.255.255.224 | 32         | 30    | 8
/28  | 255.255.255.240 | 16         | 14    | 16
/29  | 255.255.255.248 | 8          | 6     | 32
/30  | 255.255.255.252 | 4          | 2     | 64
```

### [MESURE] Formule universelle : Trouver le bloc

#### **Pour trouver dans quel bloc se trouve une IP :**

```
FORMULE :
Réseau = (IP_dernier_octet ÷ Taille_bloc) × Taille_bloc
         ^ Division entière (garder seulement le quotient)

Broadcast = Réseau + Taille_bloc - 1
```

#### **Exemples avec différents masques :**

```
EXEMPLE 1 : IP = 192.168.1.75/26

Taille bloc /26 = 64
Réseau = (75 ÷ 64) × 64 = 1 × 64 = 64
Broadcast = 64 + 64 - 1 = 127

Réseau : 192.168.1.64
Broadcast : 192.168.1.127
Plage : 192.168.1.65 à 192.168.1.126

---

EXEMPLE 2 : IP = 10.20.30.200/27

Taille bloc /27 = 32
Réseau = (200 ÷ 32) × 32 = 6 × 32 = 192
Broadcast = 192 + 32 - 1 = 223

Réseau : 10.20.30.192
Broadcast : 10.20.30.223
Plage : 10.20.30.193 à 10.20.30.222

---

EXEMPLE 3 : IP = 172.16.5.15/28

Taille bloc /28 = 16
Réseau = (15 ÷ 16) × 16 = 0 × 16 = 0
Broadcast = 0 + 16 - 1 = 15

Réseau : 172.16.5.0
Broadcast : 172.16.5.15
Plage : 172.16.5.1 à 172.16.5.14
```

---

## - PARTIE 4 : Exercices avec TOUTES les combinaisons <a name="partie4"></a>

### [FORCE] Exercice 1 : IP donnée -> Tout trouver

**Énoncé :** IP = `172.20.40.90/25`

**Solution complète :**

```
Données :
IP : 172.20.40.90/25
Taille bloc /25 : 128

Calcul du réseau :
90 ÷ 128 = 0 (quotient)
Réseau = 0 × 128 = 0
Adresse réseau : 172.20.40.0

Calcul du broadcast :
Broadcast = 0 + 128 - 1 = 127
Adresse broadcast : 172.20.40.127

Plage utilisable :
Première : 172.20.40.1
Dernière : 172.20.40.126
Plage : 172.20.40.1 à 172.20.40.126

Nombre d'hôtes : 126

Représentation du bloc :
172.20.40.0   <- Réseau (inutilisable)
172.20.40.1   <- Première IP utilisable
172.20.40.2
...
172.20.40.90  <- Notre IP (dans ce bloc)
...
172.20.40.126 <- Dernière IP utilisable
172.20.40.127 <- Broadcast (inutilisable)
```

---

### [FORCE] Exercice 2 : Broadcast donné -> Tout trouver

**Énoncé :** Broadcast = `192.168.50.127/25`

**Solution complète :**

```
Données :
Broadcast : 192.168.50.127/25
Taille bloc /25 : 128

Méthode 1 (soustractive) :
Réseau = Broadcast - (Taille - 1)
Réseau = 127 - (128 - 1) = 127 - 127 = 0
Adresse réseau : 192.168.50.0

Méthode 2 (division) :
127 ÷ 128 = 0
Réseau = 0 × 128 = 0
Adresse réseau : 192.168.50.0

Plage utilisable :
Première : 192.168.50.1
Dernière : 192.168.50.126

Vérification :
Bloc : 0 à 127 (128 adresses) [OK]
Broadcast à la fin : 127 [OK]
```

---

### [FORCE] Exercice 3 : Deux IP -> Même réseau ?

**Énoncé :**
- IP1 = `10.10.10.50/25`
- IP2 = `10.10.10.200/25`

**Solution complète :**

```
Analyse IP1 :
50 ÷ 128 = 0
Réseau IP1 = 0 × 128 = 0
-> Réseau : 10.10.10.0
-> Bloc : 0 à 127

Analyse IP2 :
200 ÷ 128 = 1
Réseau IP2 = 1 × 128 = 128
-> Réseau : 10.10.10.128
-> Bloc : 128 à 255

Comparaison :
10.10.10.0 ≠ 10.10.10.128

RÉPONSE : NON, réseaux différents

Détail :
IP1 (50) est dans le 1er sous-réseau : 0-127
IP2 (200) est dans le 2ème sous-réseau : 128-255

Communication :
Pour que IP1 et IP2 communiquent, il faut passer par un routeur
```

---

### [FORCE] Exercice 4 : Réseau donné -> Tout trouver

**Énoncé :** Réseau = `192.168.100.128/25`

**Solution complète :**

```
Données :
Réseau : 192.168.100.128/25
Taille bloc /25 : 128

Le réseau commence à 128

Calcul du broadcast :
Broadcast = Réseau + Taille - 1
Broadcast = 128 + 128 - 1 = 255
Adresse broadcast : 192.168.100.255

Plage utilisable :
Première : 192.168.100.128 + 1 = 192.168.100.129
Dernière : 192.168.100.255 - 1 = 192.168.100.254

Contexte :
C'est le 2ème sous-réseau /25 dans 192.168.100.0/24
Premier /25 : 0 à 127
Deuxième /25 : 128 à 255 <- Nous sommes ici

Nombre d'hôtes : 126
```

---

### [FORCE] Exercice 5 : Plage donnée -> Trouver le masque

**Énoncé :**
- Première IP utilisable : `172.30.20.65`
- Dernière IP utilisable : `172.30.20.126`

**Solution complète :**

```
ÉTAPE 1 : Trouver réseau et broadcast

Première utilisable : 172.30.20.65
Réseau = 65 - 1 = 64

Dernière utilisable : 172.30.20.126
Broadcast = 126 + 1 = 127

ÉTAPE 2 : Calculer le nombre d'adresses

Nombre total = Broadcast - Réseau + 1
             = 127 - 64 + 1
             = 64 adresses

ÉTAPE 3 : Trouver la puissance de 2

64 = 2^6
6 bits pour les hôtes

ÉTAPE 4 : Calculer le CIDR

CIDR = 32 - 6 = /26

RÉPONSE : Le masque est /26 ou 255.255.255.192

Vérification :
/26 -> Taille bloc = 64 [OK]
Réseau : 172.30.20.64
Broadcast : 172.30.20.127 [OK]
Hôtes : 64 - 2 = 62 hôtes utilisables
Plage : 65 à 126 (62 adresses) [OK]
```

---

### [FORCE] Exercice 6 : Besoin d'hôtes -> Calculer masque

**Énoncé :** Vous devez connecter 50 ordinateurs dans un réseau.

**Solution complète :**

```
ÉTAPE 1 : Calculer les adresses nécessaires

Hôtes nécessaires : 50
+ Adresse réseau : 1
+ Adresse broadcast : 1
Total : 52 adresses minimum

ÉTAPE 2 : Trouver la puissance de 2 supérieure

2^5 = 32   (trop petit)
2^6 = 64   (suffisant) [OK]

ÉTAPE 3 : Calculer le masque

Bits hôtes : 6
CIDR = 32 - 6 = /26
Masque : 255.255.255.192

ÉTAPE 4 : Vérification

/26 -> 2^6 - 2 = 62 hôtes utilisables
62 > 50 [OK] (suffisant)

RÉPONSE : Utiliser un masque /26

Alternative :
Si on utilise /27 (32 adresses) :
2^5 - 2 = 30 hôtes (insuffisant car < 50)

Si on utilise /25 (128 adresses) :
2^7 - 2 = 126 hôtes (suffisant mais gaspillage)

Conclusion : /26 est le choix optimal
```

---

### [FORCE] Exercice 7 : Cas complexe avec /26

**Énoncé :** IP = `10.50.100.150/26`

**Solution complète :**

```
Données :
IP : 10.50.100.150/26
Taille bloc /26 : 64

Calcul du réseau :
150 ÷ 64 = 2,34... -> Quotient = 2
Réseau = 2 × 64 = 128
Adresse réseau : 10.50.100.128

Calcul du broadcast :
Broadcast = 128 + 64 - 1 = 191
Adresse broadcast : 10.50.100.191

Plage utilisable :
Première : 10.50.100.129
Dernière : 10.50.100.190

Visualisation des 4 sous-réseaux /26 dans ce /24 :
[0-63]     -> 10.50.100.0/26
[64-127]   -> 10.50.100.64/26
[128-191]  -> 10.50.100.128/26  <- Notre IP (150) est ici
[192-255]  -> 10.50.100.192/26

Contexte :
150 est bien dans l'intervalle [128-191] [OK]

Configuration typique :
IP machine : 10.50.100.150/26
Passerelle : 10.50.100.129 (première IP)
DNS : 10.50.100.130
Broadcast : 10.50.100.191
```

---

### [FORCE] Exercice 8 : Multi-masques (/27)

**Énoncé :** IP = `192.168.5.210/27`

**Solution complète :**

```
Données :
IP : 192.168.5.210/27
Taille bloc /27 : 32
Masque : 255.255.255.224

Calcul du réseau :
210 ÷ 32 = 6,5625 -> Quotient = 6
Réseau = 6 × 32 = 192
Adresse réseau : 192.168.5.192

Calcul du broadcast :
Broadcast = 192 + 32 - 1 = 223
Adresse broadcast : 192.168.5.223

Plage utilisable :
Première : 192.168.5.193
Dernière : 192.168.5.222
Nombre d'hôtes : 30

Visualisation des 8 sous-réseaux /27 dans ce /24 :
0.   [0-31]     -> 192.168.5.0/27
1.   [32-63]    -> 192.168.5.32/27
2.   [64-95]    -> 192.168.5.64/27
3.   [96-127]   -> 192.168.5.96/27
4.   [128-159]  -> 192.168.5.128/27
5.   [160-191]  -> 192.168.5.160/27
6.   [192-223]  -> 192.168.5.192/27  <- Notre IP (210) est ici
7.   [224-255]  -> 192.168.5.224/27

Vérification :
210 est bien dans [192-223] [OK]
```

---

## [GRAPHIQUE] TABLEAU RÉCAPITULATIF COMPLET

### Formules à connaître par cœur

```
┌─────────────────────────────────────────────────────────────────┐
│  DONNÉE              ->  COMMENT TROUVER LE RESTE                │
├─────────────────────────────────────────────────────────────────┤
│  IP + CIDR           ->  Réseau = (IP ÷ Taille) × Taille        │
│                         Broadcast = Réseau + Taille - 1          │
├─────────────────────────────────────────────────────────────────┤
│  Broadcast + CIDR    ->  Réseau = (Broadcast ÷ Taille) × Taille │
│                         ou Réseau = Broadcast - Taille + 1       │
├─────────────────────────────────────────────────────────────────┤
│  Réseau + CIDR       ->  Broadcast = Réseau + Taille - 1        │
├─────────────────────────────────────────────────────────────────┤
│  Réseau + Broadcast  ->  Taille = Broadcast - Réseau + 1        │
│                         CIDR = 32 - log₂(Taille)                │
├─────────────────────────────────────────────────────────────────┤
│  Nb d'hôtes voulus   ->  Taille = 2^n où 2^n ≥ (hôtes + 2)      │
│                         CIDR = 32 - n                            │
└─────────────────────────────────────────────────────────────────┘
```

### Table de correspondance complète

```
CIDR | Masque décimal    | Bits | Taille | Hôtes | Sous-réseaux
     |                   | hôte | bloc   | util. | dans /24
-----|-------------------|------|--------|-------|-------------
/24  | 255.255.255.0     | 8    | 256    | 254   | 1
/25  | 255.255.255.128   | 7    | 128    | 126   | 2
/26  | 255.255.255.192   | 6    | 64     | 62    | 4
/27  | 255.255.255.224   | 5    | 32     | 30    | 8
/28  | 255.255.255.240   | 4    | 16     | 14    | 16
/29  | 255.255.255.248   | 3    | 8      | 6     | 32
/30  | 255.255.255.252   | 2    | 4      | 2     | 64
/31  | 255.255.255.254   | 1    | 2      | 2*    | 128
/32  | 255.255.255.255   | 0    | 1      | 1*    | 256

* /31 et /32 sont des cas spéciaux (liens point-à-point, hôte unique)
```

---

## [OBJECTIF] ASTUCES ET PIÈGES À ÉVITER

### [OK] Astuces pour calculer rapidement

```
1. Mémoriser les tailles de blocs :
   /24 -> 256    /25 -> 128    /26 -> 64
   /27 -> 32     /28 -> 16     /29 -> 8    /30 -> 4

2. Pour trouver le réseau, faire une division entière :
   IP ÷ Taille_bloc (garder seulement le quotient entier)

3. Les réseaux /25 commencent toujours à 0 ou 128

4. Les réseaux /26 commencent à 0, 64, 128, ou 192

5. Les réseaux /27 commencent tous les 32 :
   0, 32, 64, 96, 128, 160, 192, 224
```

### [X] Pièges courants

```
PIÈGE 1 : Oublier le -1 pour le broadcast
[X] Broadcast = Réseau + Taille
[OK] Broadcast = Réseau + Taille - 1

PIÈGE 2 : Confondre hôtes totaux et hôtes utilisables
Taille bloc = 128
[X] 128 hôtes utilisables
[OK] 126 hôtes utilisables (128 - 2)

PIÈGE 3 : Oublier la division entière
150 ÷ 64 = 2,34
[X] Réseau = 2,34 × 64
[OK] Réseau = 2 × 64 (quotient entier seulement)

PIÈGE 4 : Ne pas vérifier si l'IP est dans le bloc
Toujours vérifier : Réseau ≤ IP ≤ Broadcast
```

---

## [RAPIDE] MÉTHODE EN 3 ÉTAPES (à appliquer PARTOUT)

```
┌──────────────────────────────────────────────────────────────┐
│  ÉTAPE 1 : IDENTIFIER                                         │
│  • Quel est le masque (CIDR) ?                               │
│  • Quelle est la taille du bloc ?                            │
│  • Quelles données ai-je ?                                   │
└──────────────────────────────────────────────────────────────┘
              v
┌──────────────────────────────────────────────────────────────┐
│  ÉTAPE 2 : CALCULER                                          │
│  • Appliquer la formule appropriée                           │
│  • Utiliser la division entière si nécessaire                │
│  • Noter tous les résultats intermédiaires                   │
└──────────────────────────────────────────────────────────────┘
              v
┌──────────────────────────────────────────────────────────────┐
│  ÉTAPE 3 : VÉRIFIER                                          │
│  • L'IP est-elle dans le bloc [Réseau, Broadcast] ?         │
│  • Broadcast = Réseau + Taille - 1 ?                         │
│  • Le nombre d'hôtes est-il cohérent ?                       │
└──────────────────────────────────────────────────────────────┘
```

Avec ces méthodes, vous pouvez résoudre **N'IMPORTE QUEL** problème d'adressage IP ! [BRAVO]


