Cryptage message – 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é uniquement par des lettres.
2- Remplir un tableau T par les ordres alphabétiques des lettres de msg de façon à ce que T[i] lui correspond de msg[i] (sachant que « A » et « a » sont d’ordre 1, « B » et « b » sont d’ordre 2 ,…).
3- Remplacer chaque T[i] par (T[i])e mod (p*q) avec p,q et e 3 constantes ayant pour valeurs respectivement 17, 19 et 5.
Le tableau T ainsi obtenu représente le code de la chaine msg.
Exemple : pour la chaine msg= ‘’bonjour’’,
T :
| 2 | 15 | 14 | 10 | 15 | 21 | 18 |
En effet ‘’B’’ est d’ordre alphabétique 2, ‘’o’’ est d’ordre alphabétique 15,…
Après avoir codé en remplaçant chaque T[i] par (T[i])e mod (p*q) on obtient :
T
| 32 | 2 | 29 | 193 | 2 | 89 | 18 |
Ecrire un programme Phyton qui permet de saisir une chaine non vide formée uniquement par des lettres, de la crypter et d’afficher le tableau de code obtenu.
Solution Algorithmique
Pour crypter un message selon le principe décrit, vous pouvez suivre l'algorithme suivant :
1- Initialisation :
Définir les constantes p, q, et e avec les valeurs respectives p = 17, q = 19, et e = 5.
2- Saisie du message : Saisir la chaîne de caractères message.
3- Remplissage du tableau T :
Créer un tableau vide T de la même taille que le message.
Pour chaque lettre messsage[i] dans le message :
Convertir la lettre en ordre alphabétique en utilisant la formule suivante :T[i] = ord(Majus(message[i])) - 64.
4- Cryptage : Pour chaque élément T[i] du tableau :
Remplacer T[i] par T[i]e mod (p * q).
5- Affichage : Afficher le tableau crypté T.
Dans cet algorithme, On va utiliser 2 fonctions et 3 procédures :
|
1 2 3 4 5 6 7 8 9 10 11 |
Algorithme cryptage_message Debut # Saisie du message et placer l'ordre alphabetique des lettres du message dans le tableau T message=saisie_message() Ecrire ('tableau T') afficher(t,len(message)) # crypter le tableau T crypter_message(t,len(message)) Ecrire ('tableau T crypte') afficher(t,len(message)) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| message | entier |
| t | tableau des entiers |
La fonction verif_createTab
Cette fonction vérifie que le message saisi contient uniquement des lettres , divise le message en caractères et place chaque caractère dans une case d'un tableau T.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Fonction verif_createTab(ch:chaîne):booleen Début i<-0 # parcourir les caracteres de la chaine et placer l'ordre alphabetique chaque lettre dans le tableau Tant que(i<long(ch)) et (('A'<=Majus(ch[i])<='Z')) faire t[i]<-ord(Majus(ch[i]))-64 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") retourner Faux Sinon Ecrire("le message est accepte") retourner Vrai Finsi Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La procédure saisie_message
Cette procédure saisit le message et placer chaque caractère du message dans une case du tableau T
|
1 2 3 4 5 6 7 8 9 |
Procédure saise_message() Début Ecrire('donner un message contenant uniquement des lettres: ') lire(ch) Tant que verif_createTab(ch)=Faux faire Ecrire('donner un message contenant uniquement des lettres: ') lire(ch) Fin tant que Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaine des caracteres |
La fonction calcul
Cette fonction calcule la formule ne mod (p * q)
|
1 2 3 4 5 6 |
Procédure calcul(n:entier):entier Début p<-17 q<-19 e<-5 #calcul de <code>n<strong><sup>e</sup></strong></code> m<-1 Pour i in range(1,e+1) faire m<-m*n Fin pour retourner m mod (p*q) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| m | entier |
| e | entier |
| p | entier |
| q | entier |
La procédure afficher
Cette procédure affiche les éléments du tableau
|
1 2 3 4 5 6 |
Procédure afficher(t:tab,n:entier): Début Pour i de 0 à n faire Ecrire('t[',i,']= ',t[i]) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La procédure crypter_message
Cette procédure crypte le tableau T
|
1 2 3 4 5 6 7 |
Procédure crypter_message(t:tab,n:entier) Début Pour i de 0 à n faire t[i]<-calcul(t[i]) Fin pour retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
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 |
from numpy import array t=array([int()]*100) def verif_createTab(ch): i=0 # parcourir les caracteres de la chaine et placer l'ordre alphabetique chaque lettre dans le tableau while(i<len(ch)) and (('A'<=ch[i].upper()<='Z')) : t[i]=ord(ch[i].upper())-64 i=i+1 if (i<len(ch)) : # si la chaine contient des caracteres non alphabetique print("la chaine contient des caracteres non alphabetique") return False else : print("le message est accepte") 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 des lettres: ') while verif_createTab(ch)==False : ch=input('donner un message contenant uniquement des lettres: ') return ch def afficher(t,n): for i in range(n): print('t['+str(i)+']= '+str(t[i])) def calcul(n): p=17 q=19 e=5 m=1 for i in range(1,e+1): m=m*n return m % (p*q) # crypter le tableau T def crypter_message(t,n): for i in range(n): t[i]=calcul(t[i]) # programme principal # Saisie du message et placer l'ordre alphabetique des lettres du message dans le tableau T message=saisie_message() print ('tableau T') afficher(t,len(message)) # crypter le tableau T crypter_message(t,len(message)) print ('tableau T crypte') afficher(t,len(message)) |
Exécution du programme
Solution en Python et Designer QT
Pour remplir un tableau d'entiers à partir d'une chaîne de caractères en Python, vous pouvez suivre les étapes suivantes :
1- Découper la chaîne de caractères en sous-chaînes contenant les entiers.
2- Convertir chaque sous-chaîne en entier.
3- Ajouter chaque entier au tableau.
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é 'ch' pour entrer des entiers .
QPushButton nommé 'remplir_bt' pour exécuter le module createTab afin de remplir le tableau à partir de la chaine 'ch'.
QPushButton nommé 'bt_crypter' pour exécuter le module crypter_message.
QLabel nommé 'msg' pour afficher un message d'erreur si ch est vide ou contient des caractères non alphabétique.
QLabel nommé 'tabt_label' pour afficher les éléments du tableau T.
Enregistrez le fichier avec l'extension .ui, par exemple tabtab-2.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 58 59 60 61 62 63 64 65 66 |
from PyQt5.uic import loadUi from PyQt5 import QtCore, QtGui from PyQt5.QtWidgets import * from PyQt5 import QtCore, QtGui, QtWidgets from numpy import array t=array([int()]*30) app = QApplication([]) windows = loadUi ("tabtab-2.ui") # Procedure qui remplit un tableau par des entiers a partir d'une chaine des caractère def createTab(): windows.tabt_label.clear() windows.msg.clear() ch = windows.message.text() global n # pour la taille di tableau if ch=="": windows.msg.setText("Veuillez remplir la chaîne") else: windows.msg.clear() # effacer le message d erreur i=0 # parcourir les caracteres de la chaine while(i<len(ch)) and (('A'<=ch[i].upper()<='Z')) : t[i]=ord(ch[i].upper())-64 i=i+1 if (i<len(ch)) : # si la chaine contient des valeurs non numeriques windows.msg.setText("la chaine contient des caracteres non alphabetique") else : tab='' for k in range (len(ch)) : tab=tab+ 't['+str(k)+']= '+ str(t[k])+ '\n' #afficher les elements du tableau windows.tabt_label.setText(tab) def calcul(n): p=17 q=19 e=5 m=1 for i in range(1,e+1): m=m*n return m % (p*q) def crypter_message(): ch = windows.message.text() tab='' for i in range (len(ch)) : t[i]=calcul(t[i]) tab=tab+ 't['+str(i)+']= '+ str(t[i])+ '\n' #afficher les elements du tableau windows.tabt_label.setText(tab) windows.remplir_bt.clicked.connect ( createTab ) windows.bt_crypter.clicked.connect (crypter_message ) windows.show() app.exec_() |
Exécution du programme
1) Remplissage du tableau T par les rangs des lettres:
2) Crypter le tableau T :
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
