Exercice 3 Métropole – Bac NSI 2025 – Jour 2

🔥🔥🔥🔥🔥
Cet exercice porte sur la programmation de base en Python, la sécurisation des communications et les réseaux. On y aborde la méthode du masque jetable, la sécurisation des communications et les réseaux.

mots clés: programmation, sécurisation des communications , réseaux

🔎 Voir les exercices similaires ↓

📘 Sujet PDF

Métropole – Bac NSI 2025 – Jour 2 Énoncé de l'exercice 3

Cet exercice porte sur la programmation de base en Python, la sécurisation des communications et les réseaux.

Partie A - La méthode du masque jetable

Dans cette partie, on s’intéresse à une méthode de chiffrement dite du masque jetable. Voici ce que l’on peut lire sur le site Wikipédia :

Le chiffrement par la méthode du masque jetable consiste à combiner le message en clair avec une clé présentant les caractéristiques très particulières suivantes :

  • la clé doit être une suite de caractères au moins aussi longue que le message à chiffrer ;

  • les caractères composant la clé doivent être choisis de façon totalement aléatoire ;

  • chaque clé, ou « masque », ne doit être utilisée qu’une seule fois (d’où le nom de masque jetable).

Illustrons cette méthode par un exemple : on souhaite chiffrer le message HELLO avec la clé aléatoire, ou « masque », WMCKL.

Pour cela, on attribue un nombre à chaque lettre, par exemple le rang dans l’alphabet, de 0 à 25.

Tableau de correspondance
Lettre A B C D E F G H I J K L M
Rang 0 1 2 3 4 5 6 7 8 9 10 11 12
Tableau de correspondance
Lettre N O P Q R S T U V W X Y Z
Rang 13 14 15 16 17 18 19 20 21 22 23 24 25

Ensuite, on additionne la valeur du rang de chaque lettre du message avec la valeur du rang correspondante dans le masque.

Enfin, si le résultat est supérieur à 25 on soustrait 26 (calcul dit « modulo 26 »).

Ainsi, le chiffrement du message HELLO avec la clé WMCKL donne le message chiffré DQNVZ comme le montre l’illustration suivante.

Figure 1. Exemple de chiffrement par la méthode du masque jetable

Figure 1. Exemple de chiffrement par la méthode du masque jetable

Source : d’après l’article Masque jetable de Wikipédia en français

(https://fr.wikipedia.org/wiki/Masque_jetable)

Dans cet exercice, on ne travaillera que sur des chaînes de caractères écrites en majuscules non accentuées (les 26 caractères allant de ‘A’ à ‘Z’).

  1. Chiffrer, par la méthode du masque jetable, le message LIBRE à l’aide de la clé EYQMT.

En Python, on crée une fois pour toutes la variable alphabet qui sera accessible et utilisable dans toutes les fonctions. Celle-ci contient la liste des 26 lettres de l’alphabet rangées dans l’ordre alphabétique :

alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
  1. Écrire une fonction Python indice qui prend pour paramètres une liste L et un élément element et renvoie l’indice de element dans la liste L.

On supposera que chaque élément de la liste L n’y apparaît qu’une seule fois et que element est bien présent dans la liste L.

Par exemple, l’appel indice(alphabet, 'K') renvoie l’entier 10.

  1. Écrire une fonction Python lettres_vers_indices qui prend pour paramètre une chaîne de caractères et renvoie, dans l’ordre, la liste des indices de ces caractères dans l’alphabet. Par exemple, l’appel lettres_vers_indices('HELLO') renvoie la liste d’entiers [7, 4, 11, 11, 14].

On dispose également d’une fonction indices_vers_lettres, qu’on ne demande pas d’écrire, permettant de convertir une liste d’entiers, compris entre 0 et 25, en une chaîne de caractères.

Par exemple, l’appel indices_vers_lettres([3, 16, 13, 21, 25]) renvoie la chaîne de caractères 'DQNVZ'.

Ci-après, on donne une fonction Python chiffrement incomplète, qui, à partir d’un message msg et d’une clé cle entrés en paramètres, renvoie la chaîne de caractères représentant le message chiffré par la méthode du masque jetable.

def chiffrement(msg, cle):
    assert len(cle) >= len(msg), 'impossible'
    indices_msg = lettres_vers_indices(msg)
    indices_cle = lettres_vers_indices(cle)
    n = len(msg)
    indices_msg_chiffre = []
    for k in range(n):                                   # ligne 7
        ind = ...
        if ind >= 26:
            ind = ...
        indices_msg_chiffre.append(ind)
    msg_chiffre = indices_vers_lettres(...)
    return msg_chiffre                                   # ligne 13
  1. Recopier et compléter les lignes 7 à 13 de la fonction chiffrement.

  2. Indiquer, en justifiant, ce que l’on observe lors de l’appel chiffrement('RESEAU', 'GFTZ').

On s’intéresse maintenant au déchiffrement d’un message chiffré par la méthode du masque jetable.

Par exemple, le déchiffrement du message DQNVZ avec la clé WMCKL donne le message HELLO.

  1. Déchiffrer le message GMEDH avec la clé FVEIT.

  2. Expliquer comment procéder pour déchiffrer un message lorsqu’on connaît la clé.

On souhaite maintenant écrire, en Python, une fonction dechiffrement qui permet de déchiffrer un message chiffré par la méthode du masque jetable.

Pour cela, on s’inspire de la fonction chiffrement dans laquelle les paramètres ainsi que les lignes 2 à 5 sont inchangées. On décide cependant de remplacer, ligne 6, le nom de la variable indices_msg_chiffre par le nom plus explicite indices_msg_dechiffre.

  1. Adapter les lignes 6 à 13 de la fonction chiffrement pour obtenir la nouvelle fonction dechiffrement.

Partie B - Sécurisation des communications

  1. Expliquer la différence entre un algorithme de chiffrement symétrique et un algorithme de chiffrement asymétrique.

Alice souhaite envoyer un message à Bob par l’intermédiaire d’un réseau informatique en utilisant un algorithme de chiffrement asymétrique.

Pour cela, Bob envoie à Alice sa clé publique. Alice chiffre ensuite le message à l’aide de la clé publique de Bob qu’elle vient de recevoir, puis elle envoie ce message chiffré à Bob.

  1. Indiquer comment Bob peut déchiffrer le message que lui envoie Alice.

  2. Expliquer comment une tierce personne pourrait se faire passer pour Alice sans que Bob ne s’en aperçoive.

  3. Expliquer brièvement le fonctionnement du protocole HTTPS.

  4. Expliquer pourquoi, pour sécuriser intégralement les communications sur Internet, on utilise le protocole HTTPS plutôt qu’un chiffrement asymétrique.

Partie C - Réseaux

Bob et Marc travaillent pour une petite compagnie d’assurances.

Leurs postes de travail font partie d’un même réseau local géré par l’administratrice système qui dispose du bloc d’adresses IPv4 192.168.110.0/24.

La notation /24 située à la suite de l’adresse 192.168.110.0 signifie que le masque de sous-réseau du réseau de cette entreprise est 255.255.255.0 : les trois premiers octets d’une adresse IP sur ce réseau permettent donc d’identifier la partie réseau de l’adresse, alors que le dernier octet permet d’identifier la partie hôte et est propre à chaque machine sur le réseau. Ce sous-réseau permet donc d’attribuer 256 adresses IPv4 différentes.

L’administratrice choisit alors d’attribuer, en représentation décimale, l’identifiant 115 pour la partie hôte du poste de travail de Bob et l’identifiant 153 pour celui de Marc.

Depuis son poste de travail, Marc souhaite tester la communication avec celui de Bob. Pour cela, il exécute la commande ping 192.168.100.115 et obtient l’affichage suivant :

--- 192.168.100.115 ping statistics ---
4 packets transmitted, 0 received, 100% packet loss, time 3060ms
  1. Expliquer l’affichage obtenu et corriger l’erreur de Marc.

Afin d’améliorer les performances et la sécurité du réseau de l’entreprise, l’administratrice système décide de séparer le réseau local en plusieurs sous-réseaux et de les relier entre eux par des routeurs. Pour cela, elle modifie le masque de sous-réseau qui devient 11111111.11111111.11111111.11100000, donné ici en représentation binaire.

  1. Donner la représentation décimale de ce masque de sous-réseau.

Pour obtenir l’adresse IPv4 du sous-réseau auquel appartient une machine, il suffit d’appliquer l’opérateur binaire ET, bit à bit, entre le masque de sous-réseau et l’adresse IPv4 de la machine.

Par exemple, prenons le dernier octet de l’adresse IPv4 de Bob dont la représentation binaire est 01110011 : en appliquant bit à bit l’opérateur binaire ET entre cet octet et l’octet correspondant dans le masque, on obtient le dernier octet de l’adresse du sous-réseau, soit 01100000.

         1 1 1 0 0 0 0 0 (224)
      ET 0 1 1 1 0 0 1 1 (115)
      ------------------
         0 1 1 0 0 0 0 0 (96)

Le poste de travail de Bob est donc sur le sous-réseau d’adresse 192.168.110.96.

  1. Indiquer le nombre total d’adresses IPv4 pouvant être attribuées sur le sous-réseau d’adresse 192.168.110.96 sur lequel se trouve Bob.

L’administratrice système attribue maintenant l’adresse IPv4 192.168.110.134 au poste de travail de Zoé, nouvelle employée de la compagnie d’assurances.

  1. Donner la représentation binaire du nombre 134.

Depuis son poste de travail, Zoé exécute les deux commandes suivantes :

  • commande n°1 : ping 192.168.110.115 ;

  • commande n°2 : ping 192.168.110.153.

  1. Indiquer, en justifiant, laquelle de ces deux commandes a produit l’affichage :

4 packets transmitted, 4 received, 0% packet loss, time 3002ms
▶✅ Correction (cliquer pour afficher) PDF

Métropole – Bac NSI 2025 – Jour 2 Correction de l'exercice 3

Partie A – Méthode du masque jetable

1. Chiffrement du message LIBRE avec la clé EYQMT

On additionne les rangs du message et de la clé, puis on soustrait 26 si le résultat dépasse 25 :

L I B R E
Message 11 8 1 17 4
Clé (EYQMT) 4 24 16 12 19
Somme 15 32 → 6 17 29 → 3 23
Chiffré P G R D X

Le message chiffré est PGRDX.

2. Fonction indice

def indice(L, element):
    for i in range(len(L)):
        if L[i] == element:
            return i

3. Fonction lettres_vers_indices

def lettres_vers_indices(chaine):
    indices = []
    for lettre in chaine:
        indices.append(indice(alphabet, lettre))
    return indices

4. Lignes 7 à 13 de la fonction chiffrement

def chiffrement(msg, cle):
    assert len(cle) >= len(msg), 'impossible'
    indices_msg = lettres_vers_indices(msg)
    indices_cle = lettres_vers_indices(cle)
    n = len(msg)
    indices_msg_chiffre = []
    for k in range(n):
        ind = indices_msg[k] + indices_cle[k]
        if ind >= 26:
            ind = ind - 26
        indices_msg_chiffre.append(ind)
    msg_chiffre = indices_vers_lettres(indices_msg_chiffre)
    return msg_chiffre

5. Appel chiffrement('RESEAU', 'GFTZ')

La clé (4 lettres) est plus courte que le message (6 lettres) : la condition de l’assertion est fausse, le programme s’arrête avec une AssertionError et le message « impossible ».

6. Déchiffrement de GMEDH avec la clé FVEIT

On soustrait les rangs de la clé à ceux du message chiffré et on ajoute 26 si le résultat est négatif :

G M E D H
Chiffré 6 12 4 3 7
Clé (FVEIT) 5 21 4 8 19
Différence 1 −9 → 17 0 −5 → 21 −12 → 14
Clair B R A V O

Le message déchiffré est BRAVO.

7. Principe du déchiffrement

On fait l’opération inverse : pour chaque lettre, on soustrait le rang de la lettre de la clé au rang de la lettre chiffrée, et on ajoute 26 si le résultat est négatif.

8. Fonction dechiffrement (lignes 6 à 13)

    indices_msg_dechiffre = []
    for k in range(n):
        ind = indices_msg[k] - indices_cle[k]
        if ind < 0:
            ind = ind + 26
        indices_msg_dechiffre.append(ind)
    msg_dechiffre = indices_vers_lettres(indices_msg_dechiffre)
    return msg_dechiffre

Partie B – Sécurisation des communications

9. Chiffrement symétrique et asymétrique

Un chiffrement symétrique utilise une seule clé secrète, partagée par l’émetteur et le destinataire, pour chiffrer et pour déchiffrer.

Un chiffrement asymétrique utilise une paire de clés : une clé publique, connue de tous, pour chiffrer, et une clé privée, gardée secrète par son propriétaire, pour déchiffrer.

10. Déchiffrement par Bob

Bob déchiffre le message avec sa clé privée, associée à la clé publique qu’Alice a utilisée.

11. Usurpation de l’identité d’Alice

La clé publique de Bob est connue de tous : n’importe qui peut chiffrer un message avec elle et l’envoyer à Bob en signant « Alice ». Rien dans ce protocole ne prouve à Bob que le message vient d’Alice.

Une tierce personne placée sur le réseau peut aussi intercepter la clé publique de Bob et envoyer sa propre clé à Alice (attaque de l’homme du milieu).

12. Principe du protocole HTTPS

HTTPS, c’est HTTP sécurisé par TLS :

le serveur envoie un certificat qui permet d’authentifier sa clé publique ;

le chiffrement asymétrique sert à échanger une clé secrète de session ;

la suite des échanges est chiffrée avec cette clé par un chiffrement symétrique.

13. Pourquoi HTTPS plutôt qu’un chiffrement asymétrique seul ?

Le chiffrement asymétrique est lent (calculs coûteux) : on ne l’utilise que pour l’échange de la clé, puis on passe au chiffrement symétrique, bien plus rapide. HTTPS apporte en plus l’authentification du serveur grâce aux certificats.

Partie C – Réseaux

14. Échec de la commande ping

Aucun paquet n’est revenu (100 % de perte) : la machine 192.168.100.115 n’a pas répondu. Marc s’est trompé d’adresse : le réseau est 192.168.110.0. Il faut taper ping 192.168.110.115.

15. Masque en décimal

11111111.11111111.11111111.11100000 s’écrit 255.255.255.224 (11100000 = 128 + 64 + 32 = 224).

16. Nombre d’adresses attribuables

Il reste 5 bits pour la partie hôte, soit 2⁵ = 32 adresses. On enlève l’adresse du sous-réseau (192.168.110.96) et l’adresse de diffusion (192.168.110.127) : 30 adresses peuvent être attribuées.

17. Écriture binaire de 134

134 = 128 + 4 + 2, donc 134 s’écrit 10000110 en binaire.

18. Commande ayant réussi

Zoé : 134 ET 224 = 10000110 ET 11100000 = 10000000 = 128 : sous-réseau 192.168.110.128.

Bob : 115 ET 224 = 96 : sous-réseau 192.168.110.96. Marc : 153 ET 224 = 10011001 ET 11100000 = 10000000 = 128 : sous-réseau 192.168.110.128.

Zoé et Marc sont dans le même sous-réseau : c’est la commande n°2 (ping 192.168.110.153) qui a produit cet affichage.

Une erreur, un oubli ? Écrivez-moi : frederic.peuriere@lfcl.pt

💻 Console Python (cliquer pour afficher)

🔎 Exercices sur des thèmes similaires