Favicon
NSI Première

Réseaux et sous-réseaux - Correction

Masque de sous-réseau

    • le masque indique que seul le premier octet est fixe; l'adresse du sous-réseau est donc : 200.0.0.0 et l'adresse de diffusion 200.255.255.255 ( respectivement première et dernière adresse )
    • En binaire, le masque s'écrit : 11111111.00000000.00000000.00000000. Dans ce masque, 8 bits correspondent donc à l'adresse réseau. L'IP s'écrira donc en notation CIDR : 200.67.80.45/8
    • La partie machine correspond aux 32 - 8 = 24 bits restants → le nombre d'IP possible est : 224, auquel il faut retirer les adresses du sous-réseau et de diffusion non-affectables à une machine, donc 224 - 2 hôtes.
    • Le masque de sous-réseau a 21 bits de poids fort à 1 ( autrement dit, la partie réseau de l'adresse est sur 21 bits ), il s'écrit donc : 11111111.11111111.11111000.000000002 = 255.255.248.0
    • Sur les 32 bits du masque, il y a donc 32 - 21 = 11 bits à 0 correspondant donc à l'adresse machine, soit 211 = 2048 IP différentes possibles
    • l'adresse 192.168.16.5 s'écrit en binaire : 11000000.10101000.00010000.00000101. Pour trouver l'adresse du sous-réseau, on ne garde que les 21 bits de poids forts, et on met tous ceux de la partie adresse machine à 0, soit : 11000000.10101000.00010000.000000002 = 192.168.16.0
    • Des machines appartiennent au même sous-réseau si l'adresse du sous-réseau est la même :
      • 192.168.16.125 = 11000000.10101000.00010000.00001100 soit une adresse de sous-réseau avec le même masque ( 21 premiers bits pour la partie réseau, les 11 de la partie machine à 0 ) : 11000000.10101000.00010000.0000000 = 192.168.16.0 ← appartient au même sous-réseau
      • 192.168.22.5 = 11000000.10101000.00010110.01111101 soit une adresse de sous-réseau : 11000000.10101000.00010000.0000000 = 192.168.16.0 ← appartient au même sous-réseau

Opérations logiques sur IP

Adresse du sous-réseau

  1. En binaire = 192.168.1.24 = 11000000.10101000.00000001.00011000, et : 255.255.255.0 = 11111111.11111111.11111111.00000000
    → ET logique entre les deux valeurs : 
    
		11000000.10101000.00000001.00011000
	ET	11111111.11111111.11111111.00000000
	=	11000000.10101000.00000001.00000000 soit : 192.168.1.0, qui est bien l'adresse du sous-réseau.
    ( cela s'explique en remarquant que le ET logique ne "conserve" que les bits de l'IP de même position que ceux à 1 du masque; les autres bits de l'IP sont eux "forcés à zéro" par les bits à 0 du masque...)
  2. Proposition de script pour la fonction : 
    
def adresse_sous_reseau(ip, masque):
    """
    Renvoie l'adresse de sous-réseau.
    Entrées :
        ip = l'IP sous la forme XXX.XXX.XXX.XXX (str)
        masque = le masque de sous-réseau sous la même forme (str)
    Retour :
        l'adresse de sous-réseau sous la même forme (str)
    """
	
	ip = ip.split('.')                    # séparation dans une liste des 4 octets de l'IP
	masque = masque.split('.')            # séparation dans une liste des 4 octets du masque; attention ces deux listes contiennent encore des chaînes, pas des nombres !
	
	sr = ""                               # chaîne vide qui contiendra l'adresse du sous-réseau
	
	for i in range(0,4):                  # pour chacun des 4 octets de l'IP et du masque
		et = int(ip[i]) & int(masque[i])   # opération ET logique entre les octets de même position après leur transtypage en entier
		sr += str(et) + '.'                # ajout de l'octet calculé ( après transtypage en chaîne ) à la chaîne 'sr'
	
	return sr
  3. Le programme principal ( appel de la fonction et affichage de l'adresse ) peut se faire sous cette forme :
    4. 
def sous_reseau(ip, masque):

	.............
	
	return sr
	
ip = input("Entrez l'IPv4 sous la forme : XXX.XXX.XXX.XXX : ")
masque = input("Entrez le masque sous la même forme : ")

print("L'adresse du sous-réseau est :", sous-reseau(ip,masque)) # apppel de la fonction et affichage du résultat

Adresse de diffusion

  1. Complément à 1 du masque : 
    
		11111111.11111111.11111111.00000000
	XOR	11111111.11111111.11111111.11111111
	=	00000000.00000000.00000000.11111111	qui correspond bien à tous les bits du masque inversés, soit : 0.0.0.255
  2. OU logique entre l'IP et le complément à 1 du masque : 
    
		11000000.10101000.00000001.00011000
	OU	00000000.00000000.00000000.11111111
	=	11000000.10101000.00000001.11111111	 soit 192.168.1.255 qui est bien l'adresse de diffusion.
  3. Proposition de script pour la fonction : 
    
def adresse_diffusion(ip, masque):
	"""
    Renvoie l'adresse de diffusion.
    Entrées :
        ip = l'IP sous la forme XXX.XXX.XXX.XXX (str)
        masque = le masque de sous-réseau sous la même forme (str)
    Retour :
        l'adresse de diffusion sous la même forme (str)
    """
	
	ip = ip.split('.')                  # séparation dans une liste des 4 octets de l'IP
	masque = masque.split('.')          # séparation dans une liste des 4 octets du masque; attention ces deux listes contiennent encore des chaînes, pas des nombres !
	
	for i in range(0,4):                # pour chaque octet du masque
   	masque[i] = int(masque[i]) ^ 255 # calcul de son complément à 1 en faisant un OU EXCLUSIF entre l'octet ( transtypé en entier ) et 255
	
	diff = ""                           # chaîne vide qui contiendra l'adresse de diffusion
	
	for i in range(0,4):                # pour chacun des 4 octets de l'IP et du complément à 1 du masque
		ou = int(ip[i]) | masque[i]      # opération OU logique entre les octets de même position après transtypage en entier ( sauf pour les éléments de la liste masque[], qui ont déja été précédemment transtypés )
		diff += str(ou) + '.'            # ajout de l'octet calculé ( après transtypage en chaîne ) à la chaîne 'sr'
	
	return diff