Cryptage des messages – Bac pratique – Section informatique – 2014
Sujet (Algo et programmation - Bac 2014)
On se propose de crypter un message, formé uniquement par des lettres majuscules et des espaces, en utilisant la méthode de chiffrement de Polybe qui consiste à :
Travail demandéEcrire un progranune en Python permettant de crypter un message donné selon un mot-clé donné en respectant les contraintes cités ci-dessus selon la méthode de chiffrement de Polybe et de stocker dans un fichier texte "Mess.Crypte.txt" le résultat de cryptage obtenu.
Solution Algorithmique
Dans cet algorithme, On va utiliser quatre fonctions et trois procédures:
- la fonction verif_mot_cle()
- la fonction saisie_mot_cle()
- la fonction verif_message()
- la procédure remplir_matrice()
- la procédure afficher_matrice()
- la fonction recherche_coordonnee()
- la procédure crypter_message()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 |
Algorithme cryptage_message Debut mot_cle <- saisie_mot_cle() # Saisie du mot-clé message <- saisie_message() # Saisie du message à crypter remplir_matrice(m, mot_cle) # Remplissage de la matrice avec mot-clé + alphabet afficher_matrice(m) # Affichage de la matrice crypter_message(message) # Cryptage du message Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| mot_cle | chaîne |
| message | chaîne |
| m | matrice |
La fonction verif_mot_cle
La fonction verif_mot_cle(ch) vérifie que le mot-clé est composé uniquement de lettres majuscules distinctes, différentes de 'W', et de longueur comprise entre 3 et 10.
La fonction examine les lettres une par une.
À chaque étape :
elle vérifie que la lettre : est une majuscule, n’est pas 'W' et n’apparaît pas ailleurs dans le mot restant.
Si une lettre ne respecte pas ces conditions, la vérification s’arrête.
Si toutes les lettres passent les tests jusqu’à la fin du mot, le mot est valide.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Fonction verif_mot_cle(ch:chaîne):booleen # Le mot-clé doit avoir une longueur comprise entre 3 et 10 Si 3 <= long(ch) <= 10 alors c <- ch[0] # On prend la première lettre ch = Sous_chaine(ch , 1, long(ch)) # On enlève cette première lettre du mot # Boucle tant que le mot n'est pas vide, que la lettre n'apparaît pas dans le reste du mot, # que la lettre est une majuscule et n'est pas 'W' Tant que (ch != '') et (ch.find(c) = -1) et ('A' <= c <= 'Z') et (c != 'W') faire c <- ch[0] # On prend la nouvelle première lettre ch <- Sous_chaine(ch , 1, long(ch)) # On enlève cette lettre Fin tant que retourner (ch = '') # Retourne Vrai si toutes les lettres sont correctes Sinon retourner Faux # Retourne False si le mot-clé n'a pas la bonne longueur Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| c | caractère |
La fonction saisie_mot_cle
Cete fonction saisie_mot_cle() garantit que le programme ne travaille qu’avec un mot-clé valide, en obligeant l’utilisateur à corriger sa saisie si nécessaire.
1- La fonction demande à l’utilisateur de saisir un mot-clé à l’aide de la fonction lire().
2- Elle appelle la fonction verif_mot_cle(ch) pour vérifier si le mot-clé respecte les règles définies (longueur, majuscules, pas de répétition, pas de 'W', etc.).
3- Boucle de répétition : tant que verif_mot_cle(ch) retourne False, la fonction redemande à l’utilisateur de saisir un nouveau mot-clé.
L’utilisateur ne peut donc pas continuer tant que le mot-clé est invalide.
4- Retour du résultat: une fois un mot-clé valide saisi, la fonction le retourne.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_mot_cle():chaine Ecrire(('donner le mot cle: ')) Lire(ch) # Saisie initiale # Tant que le mot-clé n'est pas valide, on redemande la saisie Tant que verif_mot_cle(ch) = Faux faire Ecrire(('donner le mot cle: ')) Lire(ch) Fin tant que retourner ch # Retourne Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La fonction verif_message
La fonction verif_message(ch) sert à valider un message composé uniquement de lettres majuscules et d’espaces, sans aucun autre caractère.
1- Initialisation : i = 0 : on commence à vérifier le message caractère par caractère depuis le début.
2- Boucle de vérification
La boucle parcourt tous les caractères sauf le dernier.
À chaque étape, elle vérifie que le caractère courant est : soit une lettre majuscule (A à Z) ou un espace
3- Après la boucle, la fonction vérifie que le dernier caractère respecte aussi la même règle.
4- Résultat retourné
Vrai : si tous les caractères du message sont des majuscules ou des espaces
Faux : dès qu’un caractère interdit est rencontré (minuscule, chiffre, symbole, etc.)
|
1 2 3 4 5 6 7 8 9 |
Fonction verif_message(ch:chaîne):booleen i <- 0 # Vérifie que chaque caractère sauf le dernier est une majuscule ou un espace Tant que (i < long(ch) - 1) et (('A' <= ch[i] <= 'Z') ou ch[i] = ' '): i <- i + 1 Fin tant que # Retourne True si le dernier caractère est aussi une majuscule ou un espace retourner ('A' <= ch[i] <= 'Z') ou (ch[i] = ' ') Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_message
Cette fonction sert à valider un message composé uniquement de lettres majuscules et d’espaces, sans aucun autre caractère.
1- La fonction demande à l’utilisateur d’entrer un message à crypter à l’aide de input().
2- Elle appelle verif_message(ch) pour vérifier que le message : ne contient que des lettres majuscules et éventuellement des espaces
3- Tant que verif_message(ch) retourne Faux, la fonction redemande à l’utilisateur de saisir le message. Cela empêche le programme de continuer avec un message invalide.
4- Retour du message: dès qu’un message valide est saisi, il est retourné par la fonction.
|
1 2 3 4 5 6 7 8 9 10 11 |
Fonction saisie_message():booleen Ecrire('donner le message a crypter: ') Lire(ch) # Saisie initiale # Tant que le message n'est pas valide, on redemande la saisie Tant que verif_message(ch) = Faux faire Ecrire('donner le message a crypter: ') Lire(ch) Fin tant que retourner ch # Retourne le message valide Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La procédure remplir_matrice
Le rôle de cette procédure est de construire une matrice de chiffrement 5×5 en utilisant un mot-clé, puis en la complétant avec le reste de l’alphabet, selon des règles précises.
Plus précisément, elle sert à :
1- placer les lettres du mot-clé en premier dans la matrice, de gauche à droite et de haut en bas.
2- éliminer toute répétition de lettres, en s’assurant qu’une lettre déjà utilisée n’apparaît plus.
3- compléter la matrice avec les autres lettres de l’alphabet, dans l’ordre alphabétique.
4- exclure la lettre “W” de l’alphabet utilisé.
Au final, la matrice obtenue contient 25 lettres différentes, toutes en majuscules, et constitue une clé de chiffrement qui sera utilisée par la suite pour coder ou décoder un message.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
Procedure remplir_matrice(m:matrice, mot_cle:chaine) alphabets <- 'ABCDEFGHIJKLMNOPQRSTUVXYZ' # Alphabet utilisé (sans 'W') k <- 0 # Indice pour parcourir le mot-clé l <- 0 # Indice pour parcourir le reste de l'alphabet Pour i de 0 à 4 faire # Parcours des lignes de la matrice 5x5 Pour j de 0 à 4 faire # Parcours des colonnes de la matrice Si k <= long(mot_cle) - 1 alors m[i][j] <- mot_cle[k] # Remplissage avec le mot-clé # On supprime la lettre utilisée du reste de l'alphabet alphabets <- alphabets[0:alphabets.find(mot_cle[k])] + alphabets[alphabets.find(mot_cle[k])+1:len(alphabets)] k <- k + 1 Sinon m[i][j] <- alphabets[l] # Remplissage avec le reste de l'alphabet l <- l + 1 Fin si Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| k | entier |
| l | entier |
La procédure afficher_matrice
Cette procédure permet d’afficher les éléments d’une matrice carrée M de taille 5x5.
1- La procédure affiche un message indiquant l’affichage de la matrice.
2- Elle parcourt la matrice ligne par ligne à l’aide de deux boucles imbriquées.
3- Les éléments d’une même ligne sont affichés sur la même ligne, séparés par des espaces.
4- Après chaque ligne, un retour à la ligne est effectué pour conserver la forme matricielle.
|
1 2 3 4 5 6 7 8 9 |
Procedure afficher_matrice(m:matrice) Ecrire(''*** Contenu de la matrice M ***'') Pour i de 0 à n-1 faire Pour j de 0 à n-1 faire Ecrire(m[i][j],' ') Fin pour Ecrire() Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La fonction recherche_coordonnee
Le rôle de la fonction recherche_coordonnee(m, c) est de localiser une lettre donnée dans une matrice 5×5 et d’en retourner les coordonnées.
1- Cette fonction parcourt la matrice ligne par ligne et colonne par colonne.
2- Elle cherche la lettre c dans la matrice m.
3- Dès que la lettre est trouvée, elle repère son numéro de ligne (i) et son numéro de colonne (j)
4- Elle retourne ces deux informations sous forme d’une chaîne de caractères.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Fonction recherche_coordonnee(m:matrice, c:caractere):chaine i <- 0 j <- 0 # Parcours de la matrice pour trouver la lettre c Tant que (i < 5) et m[i][j] != c faire j <- 0 Tant que (j < 5) et m[i][j] != c faire j <- j + 1 Si m[i][j] != c alors i <- i + 1 Fin si Fin tant que Fin tant que # Retourne la position de la lettre sous forme de chaîne "ij" retourner Convch(i) + Convch(j) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La procédure crypter_message
Le rôle de la procédure crypter_message(ch) est de chiffrer un message clair en utilisant la matrice de Polybe, puis d’enregistrer et d’afficher le message chiffré.
1- Elle parcourt le message caractère par caractère.
2- Pour chaque caractère :
- l’espace est conservé tel quel, sans chiffrement.
- la lettre W est traitée comme la lettre V et remplacée par ses coordonnées dans la matrice.
- toute autre lettre majuscule est remplacée par les coordonnées (ligne, colonne) correspondant à sa position dans la matrice de Polybe.
3- Le message chiffré obtenu est affiché à l’écran et enregistré dans le fichier texte Mess_Crypte.txt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Procédure crypter_message(ch:chaine) Ecrire('*** Contenu du fichier Mess_Crypte.txt ***') Ouvrir(f , "Mess_Crypte.txt", "w") ch_crypter <- '' Pour i de 0 à long(ch)-1 faire Si ch[i] = ' ' alors ch_crypter <- ch_crypter + ' ' # Les espaces restent inchangés Sinon ch[i] = 'W': ch_crypter <- ch_crypter + recherche_coordonnee(m, 'V') # Remplace 'W' par la coordonnée de 'V' Sinon ch_crypter = ch_crypter + recherche_coordonnee(m, ch[i]) # Lettre → coordonnée dans la matrice Fin si Ecrire(f , ch_crypter) # Écriture dans le fichier Ecrire(ch_crypter) # Affichage du message crypté Fin pour Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| i | entier |
| ch_crypter | chaîne |
Solution en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 10 # Nombre maximal de lignes pour la matrice colonnes = 10 # Nombre maximal de colonnes pour la matrice # Création d'une matrice "m" de taille lignes x colonnes initialisée par des objets de type 'str' # Chaque élément de la matrice est initialisé par la classe str (sera remplacé par des lettres) m = array([[str] * colonnes] * lignes) # -------------------------------------------------- # Fonction qui vérifie la validité d'un mot-clé # -------------------------------------------------- def verif_mot_cle(ch): # Le mot-clé doit avoir une longueur comprise entre 3 et 10 if 3 <= len(ch) <= 10: c = ch[0] # On prend la première lettre ch = ch[1:len(ch)] # On enlève cette première lettre du mot # Boucle tant que le mot n'est pas vide, que la lettre n'apparaît pas dans le reste du mot, # que la lettre est une majuscule et n'est pas 'W' while (ch != '') and (ch.find(c) == -1) and ('A' <= c <= 'Z') and (c != 'W'): c = ch[0] # On prend la nouvelle première lettre ch = ch[1:len(ch)] # On enlève cette lettre return (ch == '') # Retourne True si toutes les lettres sont correctes else: return False # Retourne False si le mot-clé n'a pas la bonne longueur # -------------------------------------------------- # Fonction pour demander à l'utilisateur de saisir un mot-clé valide # -------------------------------------------------- def saisie_mot_cle(): ch = input('donner le mot cle: ') # Saisie initiale # Tant que le mot-clé n'est pas valide, on redemande la saisie while verif_mot_cle(ch) == False: ch = input('donner le mot cle: ') return ch # Retourne le mot-clé valide # -------------------------------------------------- # Fonction qui vérifie la validité du message # -------------------------------------------------- def verif_message(ch): i = 0 # Vérifie que chaque caractère sauf le dernier est une majuscule ou un espace while (i < len(ch) - 1) and (('A' <= ch[i] <= 'Z') or ch[i] == ' '): i = i + 1 # Retourne True si le dernier caractère est aussi une majuscule ou un espace return ('A' <= ch[i] <= 'Z') or (ch[i] == ' ') # -------------------------------------------------- # Fonction pour demander à l'utilisateur de saisir un message valide # -------------------------------------------------- def saisie_message(): ch = input('donner le message a crypter: ') # Saisie initiale # Tant que le message n'est pas valide, on redemande la saisie while verif_message(ch) == False: ch = input('donner le message a crypter: ') return ch # Retourne le message valide # -------------------------------------------------- # Procedure pour remplir la matrice avec le mot-clé et le reste de l'alphabet # -------------------------------------------------- def remplir_matrice(m, mot_cle): alphabets = 'ABCDEFGHIJKLMNOPQRSTUVXYZ' # Alphabet utilisé (sans 'W') k = 0 # Indice pour parcourir le mot-clé l = 0 # Indice pour parcourir le reste de l'alphabet for i in range(5): # Parcours des lignes de la matrice 5x5 for j in range(5): # Parcours des colonnes de la matrice if k <= len(mot_cle) - 1: m[i][j] = mot_cle[k] # Remplissage avec le mot-clé # On supprime la lettre utilisée du reste de l'alphabet alphabets = alphabets[0:alphabets.find(mot_cle[k])] + alphabets[alphabets.find(mot_cle[k])+1:len(alphabets)] k = k + 1 else: m[i][j] = alphabets[l] # Remplissage avec le reste de l'alphabet l = l + 1 # -------------------------------------------------- # Procedure pour afficher le contenu de la matrice # -------------------------------------------------- def afficher_matrice(m): print('*** Contenu de la matrice M ***') for i in range(5): for j in range(5): print(m[i][j], end=' ') print() # -------------------------------------------------- # Fonction qui recherche la coordonnée d'une lettre dans la matrice # -------------------------------------------------- def recherche_coordonnee(m, c): i = 0 j = 0 # Parcours de la matrice pour trouver la lettre c while (i < 5) and m[i][j] != c: j = 0 while (j < 5) and m[i][j] != c: j = j + 1 if m[i][j] != c: i = i + 1 # Retourne la position de la lettre sous forme de chaîne "ij" return str(i) + str(j) # -------------------------------------------------- # Procedure qui crypte le message en utilisant la matrice # -------------------------------------------------- def crypter_message(ch): print('*** Contenu du fichier Mess_Crypte.txt ***') f = open("Mess_Crypte.txt", "w") ch_crypter = '' for i in range(len(ch)): if ch[i] == ' ': ch_crypter = ch_crypter + ' ' # Les espaces restent inchangés elif ch[i] == 'W': ch_crypter = ch_crypter + recherche_coordonnee(m, 'V') # Remplace 'W' par la coordonnée de 'V' else: ch_crypter = ch_crypter + recherche_coordonnee(m, ch[i]) # Lettre → coordonnée dans la matrice f.write(ch_crypter) # Écriture dans le fichier print(ch_crypter) # Affichage du message crypté f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- mot_cle = saisie_mot_cle() # Saisie du mot-clé message = saisie_message() # Saisie du message à crypter remplir_matrice(m, mot_cle) # Remplissage de la matrice avec mot-clé + alphabet afficher_matrice(m) # Affichage de la matrice crypter_message(message) # Cryptage du message |
Exécution du programme
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
