Corrigé bac NSI 2025 Métropole jour 2 — Exercice 3 : Masque jetable : chiffrement symétrique, HTTPS et découpage en sous-réseaux IPv4

Partie A – La méthode du masque jetable

1. On additionne rang par rang, puis on retranche 26 dès que la somme dépasse 25 :

Le message chiffré est PGRDX. Seules les colonnes I et R ont nécessité la soustraction ($32-26=6$, $29-26=3$).

2. La fonction prend deux paramètres, la liste L et l'élément cherché, comme le montre l'appel indice(alphabet, 'K'). On parcourt la liste jusqu'à trouver l'élément ; l'hypothèse de présence garantit que la boucle s'arrête :

def indice(L, element):
    """renvoie l'indice de element dans la liste L
    (element y est présent, une seule fois)"""
    i = 0
    while L[i] != element:
        i = i + 1
    return i

indice(alphabet, 'K') renvoie 10, indice(alphabet, 'A') renvoie 0 et indice(alphabet, 'Z') renvoie 25. Une variante avec for i in range(len(L)): et return i dès que L[i] == element est tout aussi correcte. Dans le pire cas (dernier élément), on fait len(L) comparaisons : recherche séquentielle, coût linéaire.

3. On applique indice à chaque caractère de la chaîne et l'on ajoute le résultat à une liste, dans l'ordre de lecture :

def lettres_vers_indices(chaine):
    """renvoie la liste des indices dans alphabet
    des caractères de chaine, dans l'ordre"""
    indices = []
    for lettre in chaine:
        indices.append(indice(alphabet, lettre))
    return indices

lettres_vers_indices('HELLO') renvoie [7, 4, 11, 11, 14] ; sur la chaîne vide elle renvoie []. La variable globale alphabet est lue directement dans la fonction, comme l'énoncé l'autorise.

4. À chaque position k, on additionne l'indice de la lettre du message et celui de la lettre de la clé, on ramène la somme entre 0 et 25, puis on reconvertit la liste des indices chiffrés en chaîne :

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

Test : chiffrement('HELLO', 'WMCKL') renvoie 'DQNVZ' (l'exemple de la Figure 1) et chiffrement('LIBRE', 'EYQMT') renvoie 'PGRDX' (question 1). Une seule soustraction suffit à la ligne 10 car la somme de deux rangs est au plus $25+25=50<52$ ; écrire ind = ind % 26 serait aussi accepté. Si la clé est plus longue que le message, seuls ses n premiers caractères servent, puisque la boucle s'arrête à n = len(msg).

5. Le message 'RESEAU' compte $6$ caractères et la clé 'GFTZ' seulement $4$ : la condition len(cle) >= len(msg) de la ligne 2 est fausse. L'instruction assert interrompt alors l'exécution en levant une exception AssertionError accompagnée du message 'impossible' ; rien n'est chiffré et la fonction ne renvoie aucune valeur. C'est conforme à la première caractéristique du masque jetable : la clé doit être au moins aussi longue que le message, faute de quoi indices_cle[k] n'existerait pas pour k = 4 et k = 5.

6. Déchiffrer, c'est retrancher le rang de la lettre de la clé à celui de la lettre chiffrée, en ajoutant 26 si le résultat est négatif :

Le message clair est BRAVO.

7. Le chiffrement ajoute, modulo 26, le rang de la lettre du masque au rang de la lettre du message ; pour l'annuler, on effectue l'opération inverse : pour chaque position, on soustrait le rang de la lettre de la clé au rang de la lettre chiffrée ; si le résultat est strictement négatif, on lui ajoute 26 pour revenir dans l'intervalle de 0 à 25 ; on convertit enfin les rangs obtenus en lettres. La clé sert donc dans les deux sens : c'est un chiffrement symétrique. On vérifie sur l'exemple du sujet : DQNVZ avec WMCKL donne $3-22=-19\to 7$ (H), $16-12=4$ (E), $13-2=11$ (L), $21-10=11$ (L), $25-11=14$ (O), soit HELLO.

8. Seules changent l'opération (soustraction), le test (résultat négatif) et la correction ($+26$) :

def dechiffrement(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_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

Tests : dechiffrement('DQNVZ', 'WMCKL') renvoie 'HELLO', dechiffrement('GMEDH', 'FVEIT') renvoie 'BRAVO' (question 6), et pour tout message m et toute clé c assez longue, dechiffrement(chiffrement(m, c), c) redonne m (vérifié sur 200 couples tirés au hasard).

Ce que le correcteur attend : la différence de deux rangs est comprise entre $-25$ et $25$ : le test est ind < 0 et non ind >= 26, et l'on ajoute 26. Un candidat qui recopie ind >= 26 sans changer le test a une fonction qui ne corrige jamais rien et renvoie des indices négatifs.

Partie B – Sécurisation des communications

9. Dans un chiffrement symétrique, une même clé secrète sert à chiffrer et à déchiffrer (le masque jetable de la Partie A, ou AES) : les deux correspondants doivent posséder cette clé, ce qui pose le problème de son échange sur un canal non sûr. Dans un chiffrement asymétrique (RSA), chaque participant possède une paire de clés : une clé publique, diffusée librement, et une clé privée, jamais transmise ; ce qui est chiffré avec la clé publique ne peut être déchiffré qu'avec la clé privée correspondante. Il n'y a plus de secret à échanger, mais les calculs sont beaucoup plus lents.

10. Le message a été chiffré avec la clé publique de Bob : seul le possesseur de la clé privée associée peut le déchiffrer. Bob déchiffre donc avec sa clé privée, qu'il n'a jamais communiquée à personne ; même un espion qui aurait capté la clé publique et le message chiffré n'en tire rien.

11. La clé publique de Bob est, par définition, publique : elle a circulé en clair sur le réseau et n'importe qui peut l'intercepter ou l'obtenir. Une tierce personne, Ève, peut donc rédiger un message de son choix, le chiffrer avec la clé publique de Bob et l'envoyer en prétendant être Alice (par exemple en signant « Alice » ou en usurpant son adresse). Bob le déchiffre normalement avec sa clé privée et n'a aucun moyen de savoir qui l'a écrit : le chiffrement asymétrique garantit la confidentialité (seul Bob peut lire), pas l'authentification de l'expéditeur. Pour s'en prémunir, Alice devrait signer son message avec sa propre clé privée, signature que Bob vérifierait avec la clé publique d'Alice.

12. HTTPS est le protocole HTTP encapsulé dans le protocole TLS (port 443 au lieu de 80). Lors de la connexion, le serveur envoie au navigateur son certificat, qui contient sa clé publique et est signé par une autorité de certification de confiance ; le navigateur vérifie ce certificat (authentification du serveur), génère une clé de session symétrique et la transmet au serveur chiffrée avec la clé publique de celui-ci (chiffrement asymétrique) ; la suite des échanges HTTP est ensuite chiffrée avec cette clé de session (chiffrement symétrique, rapide). HTTPS apporte ainsi la confidentialité, l'authentification du serveur et l'intégrité des données (toute altération est détectée).

13. Un chiffrement asymétrique seul présente deux défauts. D'abord il est lent : ses calculs sur de grands nombres sont beaucoup plus coûteux que ceux d'un algorithme symétrique, et chiffrer ainsi tout le trafic d'une page web ou d'une vidéo serait prohibitif ; HTTPS ne l'emploie que pour échanger la clé de session, puis chiffre le reste en symétrique. Ensuite, comme l'a montré la question 11, il n'authentifie pas l'interlocuteur : rien n'empêche un pirate de se faire passer pour le serveur (ou pour Alice) ; HTTPS règle ce point avec le certificat délivré par une autorité de confiance, et garantit en plus l'intégrité des échanges. HTTPS combine donc le meilleur des deux méthodes : la sécurité de l'échange de clé asymétrique, la vitesse du chiffrement symétrique et l'authentification par certificat.

Partie C – Réseaux

14. Marc a fait une faute de frappe dans le troisième octet : il a tapé 192.168.<strong>100.115 au lieu de 192.168.<strong>110.115. Avec le masque 255.255.255.0, les trois premiers octets identifient le réseau : l'adresse tapée appartient au réseau 192.168.100.0/24, qui n'est pas le réseau local de l'entreprise. Aucune machine ne répond à cette adresse (ou les paquets ne sont même pas routés) : les quatre requêtes ICMP envoyées par ping restent sans réponse, d'où « 4 packets transmitted, 0 received, 100 % packet loss ». La commande correcte, avec l'identifiant d'hôte 115 de Bob, est ping 192.168.110.115.

15. On convertit chaque octet : 11111111 vaut $255$ et 11100000 vaut $128+64+32=224$. Le masque s'écrit 255.255.255.224, soit /27 (27 bits à 1).

16. Le masque laisse $32-27=5$ bits à 0 pour la partie hôte : il y a $2^5=32$ combinaisons, soit 32 adresses sur le sous-réseau 192.168.110.96, de 192.168.110.96 à 192.168.110.127 (c'est la convention du sujet, qui compte 256 adresses pour le /24). En pratique deux d'entre elles sont réservées, l'adresse du sous-réseau .96 (bits hôte tous à 0) et l'adresse de diffusion .127 (bits hôte tous à 1), si bien que $2^5-2=30$ machines au plus peuvent recevoir une adresse. Le réseau initial est ainsi découpé en $2^3=8$ sous-réseaux de 32 adresses.

17. $134=128+4+2=2^7+2^2+2^1$, d'où l'écriture binaire 10000110 (on vérifie : $128+0+0+0+0+4+2+0=134$).

18. On calcule le sous-réseau de chaque poste par un ET bit à bit du dernier octet avec 11100000 :

Zoé et Marc sont sur le même sous-réseau 192.168.110.128 (adresses de .128 à .159) : les paquets circulent directement entre leurs postes et les quatre réponses reviennent. Bob est sur un autre sous-réseau (192.168.110.96), désormais séparé par un routeur, mis en place précisément pour la sécurité : la communication n'est plus directe et peut être filtrée. C'est donc la commande n°2, ping 192.168.110.153 vers le poste de Marc, qui a produit l'affichage « 4 received, 0 % packet loss ».

Ce que le correcteur attend : le calcul du ET pour les trois adresses, qui montre que 134 et 153 partagent les trois premiers bits 100 de leur dernier octet alors que 115 commence par 011 ; répondre « la n°2 » sans ce calcul ne justifie rien.