Cryptage messages – Bac théorique – Section informatique – 2011
Sujet (Algo et programmation - Bac 2011)
Dans le cadre de la réalisation d'un projet scientifique, deux chercheurs résidants dans deux pays différents, s'échangent des données sur Internet. Pour assurer la confidentialité de leur projet, les messages &changes sont cryptes.
Le message initial se compose au maximum de 50 lignes et chaque ligne contient 50 caractères au maximum. Ce message est stocke dans un fichier texte intitule « Txtinit.txt » sur la rapine du lecteur C.
En supposant que ce texte est déjà saisi, on se propose de créer un deuxième fichier texte intitule « TxtCryp.txt » contenant le message qui sera crypte, de la manière suivante :
Première étape :
Remplir une matrice d'entiers MC par les codes ASCII (en base 10) des caractères du message initial. Chaque ligne de la matrice contiendra les codes ASCII des caractères d'une ligne du fichier « TxtInit.txt ».
Le nombre de lignes de la matrice MC est egal au nombre de lignes du fichier « Txtinit.txt » et le nombre de colonnes de la matrice MC est egal a la longueur (long_max) de la plus longue ligne du fichier.
Pour les lignes avant une longueur inferieure a long_max, on complète les cases restées vides par le code ASCII du caractère espace (qui est égal a 32).
Deuxième étape :
Convertir, dans la même matrice, tous les éléments de MC en base 8.
Troisième étape :
Stocker dans « TxtCryp.txt », les colonnes de la matrice MC, de la colonne la plus a gauche a la colonne la plus a droite. Chaque colonne de la matrice MC occupera une ligne et les éléments de cette ligne seront séparés par le caractère espace.
Travail demandé :
1. Analyser le problème en le décomposant en modules et en déduire L'algorithme programme principal.
2. Analyser chacun des modules envisages précédemment et en déduire les algorithmes correspondants.
Solution Algorithmique
Dans cet algorithme, On va utiliser trois fonctions et cinq procédures:
- la fonction saisie_n()
- la fonction saisie_ch()
- la procédure remplir_fichierTxtInit()
- la procédure remplir_matrice_mc()
- la procédure afficher_matrice_mc()
- la fonction decimal_vers_base8()
- la procédure remplir_matrice_mc_base8()
- la procédure remplir_fichierTxtCryp()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Algorithme cryptage_messages Debut n <- saisie_n() long_max <- 0 Ecrire("**** Remplir le fichier TxtInit *****") remplir_fichierTxtInit(n) remplir_matrice_mc(mc) Ecrire("**** Matrice MC *****") afficher_matrice_mc(mc, n) remplir_matrice_mc_base8(mc, n) Ecrire("**** Matrice MC en base 8 *****") afficher_matrice_mc(mc, n) Ecrire("**** Contenu du fichier crypte *****") remplir_fichierTxtCryp(mc, n) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| long_max | entier |
| m | matrice des entiers |
La fonction saisie_n
Cette procédure permet de saisir un entier compris strictement entre deux bornes inf et sup, en contrôlant la validité de la saisie.
Plus précisément :
il demande à l’utilisateur d’entrer un entier n tel que 0 < n < 50. si la valeur saisie n’appartient pas à cet intervalle, le programme redemande la saisie jusqu’à obtenir une valeur correcte. une fois la saisie valide, la fonction retourne l’entier n.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction saisie_n():entier # Première saisie de l'entier Ecrire('donner n telque 0<n<50: ') Lire(n) # Tant que n n'est pas dans l'intervalle demandé, # on redemande la saisie Tant que (n <= 0) ou (n >= 50) faire Ecrire('donner n telque 0<n<50: ') Lire(n) Fin tant que # Retourne la valeur correcte saisie retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | chaîne |
La fonction saisie_ch
La fonction saisie_ch permet de saisir une chaîne de caractères valide dont la longueur est comprise entre 1 et 50 caractères.
Elle demande à l’utilisateur de saisir une chaîne.
Elle vérifie la longueur de la chaîne saisie.
Tant que la chaîne est vide ou dépasse 50 caractères, la saisie est redemandée.
Une fois la chaîne valide, elle est retournée par la fonction.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_ch(): chaine Ecrire('donner une chaine formee de 50 caracteres au maximum: ') Lire(ch) # Tant que la chaîne n'est pas valide, on redemande la saisie Tant que (long(ch) = 0) ou (long(ch) > 50) faire Ecrire('donner une chaine formee de 50 caracteres au maximum: ') Lire(ch) Fin tant que retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La procédure remplir_fichierTxtInit
La procédure remplir_fichierTxtInit permet de remplir le fichier texte TxtInit.txt avec n chaînes de caractères saisies au clavier.
Elle ouvre le fichier TxtInit.txt en mode écriture.
Elle demande à l’utilisateur de saisir n chaînes (à l’aide de la fonction saisie_ch).
Elle détermine et mémorise la longueur maximale des chaînes saisies dans la variable globale long_max.
Elle écrit chaque chaîne sur une ligne du fichier.
Elle ferme le fichier après la fin de l’écriture.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Procédure remplir_fichierTxtInit(n:entier) Ouvrir(f, "TxtInit.txt" , "w") # Ouverture du fichier en écriture Pour i de 0 à n-1 faire ch <- saisie_ch() # Saisie d'une chaîne Si long_max < long(ch) alors long_max <- long(ch) # Mise à jour de la longueur maximale Finsi Ecrire(f , ch + '\n') # Écriture dans le fichier Fin si Fermer(f) # Fermeture du fichier Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| long_max | entier (variable globale) |
La procédure remplir_matrice_mc
La procédure remplir_matrice_mc permet de remplir la matrice mc à partir du contenu du fichier TxtInit.txt.
Elle lit toutes les lignes du fichier texte.
Chaque chaîne lue est traitée caractère par caractère.
Chaque caractère est converti en son code ASCII et stocké dans la matrice mc.
Si une chaîne est plus courte que la longueur maximale long_max, les cases restantes de la ligne sont complétées par le code ASCII 32 (espace).
La matrice obtenue contient ainsi des lignes de longueur uniforme correspondant aux codes ASCII des caractères des chaînes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Procédure remplir_matrice_mc(mc:matrice) Ouvrir( f , "TxtInit.txt" , "r") # Ouverture du fichier en lecture lignes <- Lire_lignes(f) i <- 0 Pour ligne dans lignes faire ch <- ligne) Pour j de 0 à long(ch)-1 faire mc[i][j] <- ord(ch[j]) # Conversion caractère → code ASCII Fin pour # Compléter par des espaces si la chaîne est plus courte Si long(ch) < long_max alors Pour j de len(ch) à long_max-1 mc[i][j] <- 32 # Code ASCII de l'espace Fin pour Fin si i <- i + 1 Fin pour Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| f | fichier |
| lignes | chaîne |
| ligne | chaîne |
| ch | chaîne |
| j | entier |
La procédure afficher_matrice_mc
La procédure afficher_matrice_mc permet d’afficher à l’écran le contenu de la matrice mc.
Elle parcourt chaque ligne de la matrice (jusqu’à n lignes).
Pour chaque ligne, elle affiche tous les éléments jusqu’à long_max colonnes, séparés par deux espaces.
Après chaque ligne, elle effectue un retour à la ligne pour que l’affichage soit lisible sous forme de matrice.
|
1 2 3 4 5 6 7 8 |
Procédure afficher_matrice_mc(mc:matrice, n:entier)) Pour i de 0 à n-1 faire Pour j de 0 à long_max-1 faire Ecrire(mc[i][j], ' ') Fin pour Ecrire() Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | fichier |
| long_max | entier (variable globale) |
La fonction decimal_vers_base8
La fonction saisie_ch permet de saisir une chaîne de caractères valide dont la longueur est comprise entre 1 et 50 caractères.
Elle demande à l’utilisateur de saisir une chaîne.
Elle vérifie la longueur de la chaîne saisie.
Tant que la chaîne est vide ou dépasse 50 caractères, la saisie est redemandée.
Une fois la chaîne valide, elle est retournée par la fonction.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction decimal_vers_base8(n:entier): entier octal <- "" # Cas particulier : n = 0 Si n = 0 alors retourner "0" Fin si # Conversion par divisions successives Tant que n > 0 faire reste <- n % 8 octal <- Convch(reste) + octal n <- n div 8 Fin tant que retourner Valeur(octal) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| octal | chaîne |
| reste | chaîne |
La procédure afficher_matrice_mc_base8
La procédure remplir_matrice_mc_base8 permet de convertir tous les éléments de la matrice mc de la base décimale (10) vers la base 8.
Elle parcourt chaque ligne et chaque colonne de la matrice jusqu’à n lignes et long_max colonnes.
Pour chaque élément, elle applique la fonction decimal_vers_base8 pour transformer le code ASCII (décimal) en sa valeur en base 8.
Après l’exécution de cette fonction, la matrice mc contient donc les codes ASCII des caractères sous forme octale.
|
1 2 3 4 5 6 7 |
Procédure remplir_matrice_mc_base8(mc:matrice, n:entier)) Pour i de 0 à n-1 faire Pour j de 0 à long_max-1 faire mc[i][j] <- decimal_vers_base8(mc[i][j]) Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | fichier |
| long_max | entier (variable globale) |
La procédure remplir_fichierTxtCryp
La procédure remplir_fichierTxtInit permet de remplir le fichier texte TxtInit.txt avec n chaînes de caractères saisies au clavier.
Elle ouvre le fichier TxtInit.txt en mode écriture.
Elle demande à l’utilisateur de saisir n chaînes (à l’aide de la fonction saisie_ch).
Elle détermine et mémorise la longueur maximale des chaînes saisies dans la variable globale long_max.
Elle écrit chaque chaîne sur une ligne du fichier.
Elle ferme le fichier après la fin de l’écriture.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Procédure remplir_fichierTxtCryp(mc:matrice ; n:entier) Ouvrir(f, "TxtInit.txt" , "w") # Ouverture du fichier en écriture Pour j de 0 à long_max-1 faire ch <- '' Pour i de 0 à n-1 faire ch <- ch + Conch(mc[i][j]) + ' ' Fin pour Ecrire(ch) # Affichage à l’écran Ecrire(f , ch + '\n') # Écriture dans le fichier Fin pour Fermer(f) # Fermeture du fichier Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| f | fichier |
| ch | chaîne |
| long_max | entier (variable globale) |
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 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 50 colonnes = 50 # Matrice mc : contiendra les codes ASCII des caractères mc = array([[int()] * colonnes] * lignes) # Variable globale qui stocke la longueur maximale # des chaînes saisies # -------------------------------------------------- # Fonction qui permet de saisir un entier n tel que 0 < n < 50 # -------------------------------------------------- def saisie_n(): n = int(input('donner nombre de lignes n telque 0<n<50: ')) # Redemande la saisie tant que n n'est pas valide while (n <= 0) or (n >= 50): n = int(input('donner nombre de lignes n telque 0<n<50: ')) return n # -------------------------------------------------- # Fonction qui permet de saisir une chaîne # de longueur comprise entre 1 et 50 caractères # -------------------------------------------------- def saisie_ch(): ch = input('donner une chaine formee de 50 caracteres au maximum: ') # Tant que la chaîne est vide ou trop longue while len(ch) == 0 or len(ch) > 50: ch = input('donner une chaine formee de 50 caracteres au maximum: ') return ch # -------------------------------------------------- # Fonction qui remplit le fichier TxtInit.txt # par n chaînes saisies au clavier # Elle détermine aussi la longueur maximale des chaînes # -------------------------------------------------- def remplir_fichierTxtInit(n): f = open("TxtInit.txt", "w") # Ouverture du fichier en écriture global long_max for i in range(n): ch = saisie_ch() # Saisie d'une chaîne if long_max < len(ch): long_max = len(ch) # Mise à jour de la longueur maximale f.write(ch + '\n') # Écriture dans le fichier f.close() # Fermeture du fichier # -------------------------------------------------- # Fonction qui remplit la matrice mc à partir # du fichier TxtInit.txt # Chaque caractère est remplacé par son code ASCII # Les cases vides sont remplies par 32 (espace) # -------------------------------------------------- def remplir_matrice_mc(mc): f = open("TxtInit.txt", "r") # Ouverture du fichier en lecture lignes = f.readlines() i = 0 for ligne in lignes: ch = ligne.rstrip('\n') # Suppression du retour à la ligne for j in range(len(ch)): mc[i][j] = ord(ch[j]) # Conversion caractère → code ASCII # Compléter par des espaces si la chaîne est plus courte if len(ch) < long_max: for j in range(len(ch), long_max): mc[i][j] = 32 # Code ASCII de l'espace i = i + 1 f.close() # -------------------------------------------------- # Fonction qui affiche la matrice mc # -------------------------------------------------- def afficher_matrice_mc(mc, n): for i in range(n): for j in range(long_max): print(mc[i][j], end=' ') print() # -------------------------------------------------- # Fonction qui convertit un nombre décimal en base 8 # sans utiliser les fonctions prédéfinies # -------------------------------------------------- def decimal_vers_base8(n): octal = "" # Cas particulier : n = 0 if n == 0: return "0" # Conversion par divisions successives while n > 0: reste = n % 8 octal = str(reste) + octal n = n // 8 return int(octal) # -------------------------------------------------- # Fonction qui convertit tous les éléments # de la matrice mc de la base 10 vers la base 8 # -------------------------------------------------- def remplir_matrice_mc_base8(mc, n): for i in range(n): for j in range(long_max): mc[i][j] = decimal_vers_base8(mc[i][j]) # -------------------------------------------------- # Fonction qui remplit le fichier TxtCryp.txt # à partir de la matrice mc (écriture colonne par colonne) # -------------------------------------------------- def remplir_fichierTxtCryp(mc, n): f = open("TxtCryp.txt", "w") # Ouverture du fichier en écriture for j in range(long_max): ch = '' for i in range(n): ch = ch + str(mc[i][j]) + ' ' print(ch) # Affichage à l’écran f.write(ch + '\n') # Écriture dans le fichier f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie_n() long_max = 0 print("**** Remplir le fichier TxtInit *****") remplir_fichierTxtInit(n) remplir_matrice_mc(mc) print("**** Matrice MC *****") afficher_matrice_mc(mc, n) remplir_matrice_mc_base8(mc, n) print("**** Matrice MC en base 8 *****") afficher_matrice_mc(mc, n) print("**** Contenu du fichier crypte *****") remplir_fichierTxtCryp(mc, n) |
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
