Cryptage message en utilisant un clé (version 2) – Bac Pratique 2015 [ Algorithme + Python ]
Travail demandé
Pour sécuriser l’envoi des messages, deux chercheurs cryptent leurs messages en utilisant le principe suivant :
1- Saisir le message à crypter msg, sachant qu’il est composé par des lettres minuscules et des espaces.
2- Saisir la clé de cryptage qui est une chaine de caractères chcle composée uniquement par des lettres minuscules et ayant la même longueur que le message à crypter.
3- Remplacer chaque lettre du message msg d’indic i par la lettre minuscule d’ordre alphabétique k sachant que :
k=ABS(ord(msg[i]-ord(chcle[i]))+1 et l’espace ne sera pas crypté.
Exemple : Soit le message « bonne reception » et soit la clé « homeofhappiness »
Message initial : b o n n e r e c e p t i o n
La clé de cryptage : h o m e o f h a p p i n e s s
Message codé : g a b j k k e n l h g e e f
En effet : La lettre « b » sera remplcé par lettre d’ordre alphabétique k= ABS(ord(‘’b’’)-ord(‘’h’’)).+1 qui est ’’g’’ à k=ABS(66-72)+1=7 qui est d’ordre alphabétique de la lettre ‘’g’’.
Ecrire un programme Python qui permet de saisir un message et une clé de cryptage puis d’afficher le message crypté.
Solution Algorithmique
L'algorithme pour crypter un message en utilisant une clé de cryptage peut être décrit de la manière suivante :
Étape 1 : Initialisation
Saisir le message à crypter (message), composé uniquement de lettres minuscules et d'espaces.
Saisir la clé de cryptage (chcle), une chaîne de caractères composée uniquement de lettres minuscules et ayant la même longueur que le message à crypter.
Étape 2 : Crypter le message
Initialiser une chaîne vide ch pour stocker le message crypté.
Pour chaque caractère message[i] du message :
Si message[i] est un espace, ajouter un espace à ch.
Sinon, calculer l'index de la nouvelle lettre cryptée :
1- Calculer la différence entre le code ASCII du caractère message[i] et celui de chcle[i].
2- Prendre la valeur absolue de cette différence, puis ajouter 1 pour obtenir l'index de la nouvelle lettre (k).
3- Convertir cet index en caractère alphabétique et ajouter ce caractère à ch.
4- Répéter l'étape 2 pour tous les caractères du message.
Étape 3 : Afficher le message crypté
Afficher la chaîne ch qui contient le message crypté.
Dans cet algorithme, On va utiliser 5 fonctions :
|
1 2 3 4 5 6 |
Algorithme cryptage_message Debut message<-saisie_message() chcle<-saisie_cle(message) Ecrire('le message crypte est : '+crypter_message(message,chcle)) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| message | chaîne des caractères |
| chcle | chaîne des caractères |
La fonction verif_message
Cette fonction vérifie que le message saisi contient uniquement des lettres minuscules et des espaces
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Fonction verif_message(ch:chaîne):booleen Début i<-0 # Verifier si la chaine est composee uniquement par des lettres minuscules et des espaces Tant que (i<len(ch)) and (('a'<=ch[i]<='z') or(ch[i]==' ')) faire i<-i+1 Fin tant que Si (i<long(ch)) alors # si la chaine contient des caracteres non alphabetique Ecrire("la chaine contient des caracteres non alphabetique ou non minuscules") retourner Faux Sinon Ecrire("le message est accepte") retourner Vrai Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction verif_cle
Cette fonction vérifie que le cle saisi contient uniquement des lettres minuscules.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction verif_cle(ch:chaîne):booleen Début i<-0 # Verifier si la chaine est composee uniquement par des lettres minuscules Tant que (i<long(ch)) et ('a'<=ch[i]<='z') faire i<-i+1 Fin tant que Si (i<long(ch)) alors # si la chaine contient des caracteres non minuscules Ecrire("le cle contient des caracteres non minuscules") retourner Faux Sinon retourner Vrai Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_message
Cette fonction saisit le message composé uniquement des lettres et des espaces
|
1 2 3 4 5 6 7 8 9 |
Fonction saise_message():chaine Début Ecrire('donner un message contenant uniquement des lettres minuscules et des espaces: ') lire(ch) Tant que verif_message(ch)=Faux faire Ecrire('donner un message contenant uniquement des lettres minuscules et des espaces: ') lire(ch) Fin tant que Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaine des caracteres |
La fonction saisie_cle
Cette fonction saisit le clé composé uniquement des chiffres et de même longueur que le message
|
1 2 3 4 5 6 7 8 9 |
Procédure saise_message(message):chaine Début Ecrire('donner un message contenant uniquement des lettres minuscules et de meme longueur que le message : ') lire(ch) Tant que verif_cle(ch)=Faux et long(ch)!=long(message) faire Ecrire('donner un message contenant uniquement des lettres minuscules et de meme longueur que le message : ') lire(ch) Fin tant que Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaine des caracteres |
La fonction crypter_message
Cette fonction crypte le message entré par l'utilisateur.
|
1 2 3 4 5 6 7 8 9 10 11 |
Fonction crypter_message(t:tab,n:entier):chaine Début ch<-'' Pour i de 0 à long(message)-1 faire Si message[i]!=' ' alors # le caractere est une lettre minuscules ch=ch+chr(abs(ord(message[i])-ord(chcle[i]))+1+96) Sinon ch=ch+' ' # ajout de l'espace Fin return ch # retourner le message crypte Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| ch | chaîne des caractères |
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 |
def verif_message(ch): i=0 # Verifier si la chaine est composee uniquement par des lettres miniscules et des espaces while(i<len(ch)) and (('a'<=ch[i]<='z') or(ch[i]==' ')) : i=i+1 if (i<len(ch)) : # si la chaine contient des caracteres non alphabetique et des espaces print("la chaine contient des caracteres non alphabetique ou non miniscule") return False else : print("le message est accepte") return True def verif_cle(ch): i=0 # Verifier si la chaine est composee uniquement par des caracteres non numeriques while(i<len(ch)) and ('a'<=ch[i]<='z') : i=i+1 if (i<len(ch)) : # si la chaine contient des caracteres non numeriques et non miniscule print("le cle contient des caracteres non alphabetique ou non miniscule") return False else : return True # Saisie du message et placer chaque caractere du message dans une case du tableau T def saisie_message(): ch=input('donner un message contenant uniquement par des lettres miniscules et des espaces: ') while verif_message(ch)==False : ch=input('donner un message contenant uniquement par des lettres miniscules et des espaces: ') return ch def saisie_cle(message): ch=input('donner une cle compose des '+str(len(message))+' lettres miniscules: ') while verif_cle(ch)==False or len(ch)!=len(message) : ch=input('donner une cle compose des '+str(len(message))+' lettres miniscules: ') return ch def crypter_message(message,chcle): ch='' for i in range(len(message)): if message[i]!=' ': ch=ch+chr(abs(ord(message[i])-ord(chcle[i]))+1+96) else: ch=ch+' ' return ch # retourner le message crypte # programme principal message=saisie_message() chcle=saisie_cle(message) print('le message crypte est : '+crypter_message(message,chcle)) |
Exécution du programme
Solution en Python et Designer QT
Pour créer une application en Python pour crypter un message, on va suivre ces étapes :
1- Créer l'interface graphique avec Qt Designer
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets:
QLineEdit nommé 'message' pour entrer un message.
QLineEdit nommé 'cle' pour entrer un cle.
QPushButton nommé 'bt_crypter' pour exécuter le module crypter_message.
QLabel nommé 'msg' pour afficher un message d'erreur et le message crypté
Enregistrez le fichier avec l'extension .ui, par exemple crypter-message.ui.
2- Créer le script Python pour l'application
Voici un exemple de script Python qui utilise l'interface graphique générée par Qt Designer.
|
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 |
from PyQt5.uic import loadUi from PyQt5 import QtCore, QtGui from PyQt5.QtWidgets import * from PyQt5 import QtCore, QtGui, QtWidgets app = QApplication([]) windows = loadUi ("code-interface.ui") def verif_message(ch): i=0 global long_message j=0 # Verifier si la chaine est composee uniquement par des lettres majuscules et des espaces while(i<len(ch)) and (('a'<=ch[i]<='z') or(ch[i]==' ')) : i=i+1 if (i<len(ch)) : # si la chaine contient des caracteres non alphabetique et des espaces print("la chaine contient des caracteres non alphabetique ou non miniscule") return False else : print("le message est accepte") return True def verif_cle(ch): i=0 # Verifier si la chaine est composee uniquement par des caracteres non numeriques while(i<len(ch)) and ('a'<=ch[i]<='z') : i=i+1 if (i<len(ch)) : # si la chaine contient des caracteres non numeriques print("lle cle contient des caracteres non alphabetique ou non miniscule") return False else : return True def crypter(): message = windows.message.text() if verif_message(message) : chcle = windows.chcle.text() if (verif_cle(chcle)) and (len(chcle)==len(message)): ch='' for i in range(len(message)): if message[i]!=' ': # le caractere est different de l'espace ch=ch+chr(abs(ord(message[i])-ord(chcle[i]))+1+96) else: ch=ch+' ' #ajout de l'espace windows.msg.setText('le message crypte est : '+ch ) else: windows.msg.setText('donner une cle compose des '+str(len(message))+' lettres miniscules: ') else: windows.msg.setText('donner un message compose par des lettres miniscules et des espaces: ') windows.bt_crypter.clicked.connect(crypter) windows.show() app.exec_() |
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
