Cryptage fichier – Bac pratique – Section informatique – 2017
Sujet (Algo et programmation - Bac 2017)
Soit "Source.txt" un fichier texte, dont chaque ligne est composée d'au maximum 100 caractères.
On se propose de réaliser le cryptage du contenu du fichier "Source.txt", ligne par ligne, pour générer un deuxième fichier texte nommé "Crypt.txt" en utilisant une clé de cryptage constituée de lettres majuscules distinctes.
Le principe de cryptage d'une ligne du fichier "Source.txt" est le suivant :
- ajouter, si c'est nécessaire, des espaces à la fin de la ligne à crypter pour que sa longueur soit multiple de celle de la clé,
- distribuer les caractères de la ligne à crypter, après ajout d'espaces, dans une matrice M de L lignes et C colonnes en commençant par le remplissage de la première ligne de la matrice, puis la deuxième ligne et ainsi de suite. C et L représentent respectivement la ongueur de la clé de cryptage et le nombre de lignes remplies de la matrice M,
- former la ligne cryptée par la concaténation des caractères des colonnes de la matrice M en commençant par la première et en ajoutant au début de chacune la lettre de la clé ayant le même indice.
Travail demandé :
- En utilisant l'éditeur de texte disponible (Bloc-notes, Notepad, Notepad++, ...), créer dans le dossier de travail le fichier texte "Source.txt" et y saisir le contenu présenté dans l'exemple en respectant le contenu de chaque ligne.
- Ecrire un programme en Python intitulé "Cryptage" permettant :
- de saisir une clé de cryptage constituée de lettres majuscules distinctes et ayant une longueur appartenant à l'intervalle 15,101,
- de crypter le contenu du fichier "Source.txt" pour générer le fichier "Crypt.txt" en utilisant le principe de cryptage décrit précédemment,
- d'afficher le contenu du fichier "Crypt.txt".
Solution Algorithmique
Dans cet algorithme, On va utiliser cinq fonctions et quatre procédures:
- la fonction saisie_lignes()
- la fonction verif_distinct()
- la fonction verif_cle()
- la fonction saisie_cle()
- la procédure remplir_fichier_source()
- la procédure remplir_matrice()
- la procédure afficher_matrice()
- la fonction crypter()
- la procédure crypter_fichier()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 |
Algorithme Cryptage Debut nbr_lignes <- 0 # Nombre de lignes réelles de la matrice cle <- saisie_cle() # Saisie de la clé n <- saisie_lignes() # Saisie du nombre de lignes remplir_fichier_source(n) # Création du fichier source crypter_fichier(m, long(cle)) # Cryptage du fichier Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| nbr_lignes | entier |
| cle | entier |
| n | n |
La fonction saisie_lignes
Cette fonction permet de demander à l’utilisateur de saisir le nombre de lignes du fichier source, en s’assurant que la valeur saisie est un entier strictement positif.
Elle lit une valeur entière saisie au clavier.
Elle vérifie que cette valeur est supérieure à 0.
Si la valeur est invalide (n ≤ 0), elle redemande la saisie jusqu’à obtenir une valeur correcte.
Elle retourne le nombre de lignes valide, qui sera utilisé pour déterminer combien de lignes seront écrites dans le fichier Source.txt.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie_lignes():entier # Première saisie du nombre de lignes Ecrire(('donner le nombre des lignes : ')) Lire(n) # Tant que n est inférieur ou égal à 0, on redemande la saisie Tant que (n <= 0) faire Ecrire(('donner le nombre des lignes : ')) Lire(n) Fin tant que # Retourne le nombre de lignes valide retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction verif_distinct
Cette fonction permet de vérifier que tous les caractères d’une chaîne ch sont distincts, c’est-à-dire qu’aucun caractère ne se répète.
1- Elle compare chaque caractère de la chaîne avec le reste de la chaîne.
2- Tant que le caractère courant n’apparaît pas dans la suite de la chaîne, elle passe au caractère suivant.
3- Si un caractère est trouvé une seconde fois, la vérification s’arrête.
4- Valeur retournée :
Vrai : si tous les caractères de la chaîne sont différents (aucune répétition).
Faux : s’il existe au moins un caractère répété.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction verif_distinct(ch:chaine):booleen c <- ch[0] # Premier caractère ch <- ch[1:len(ch1)] # Reste de la chaîne # Tant que le caractère n'est pas trouvé dans le reste # et que la chaîne n'est pas vide Tant que (Pos(ch,c) = -1) et (long(ch) != 0) faire c <- ch[0] ch <- Sous_chaine(ch1, 1 , long(ch)) Fin tant que # Retourne Vrai si aucun caractère répété retourner (Pos(ch,(c) = -1) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| c | caractère |
La fonction verif_cle
Cette fonction teste la validité d’une clé de cryptage en vérifiant sa longueur, l’unicité de ses caractères et le fait qu’elle ne contient que des lettres majuscules.
1- La fonction commence par vérifier la longueur de la chaîne et l’absence de caractères répétés à l’aide de la fonction verif_distinct.
2- Ensuite, elle parcourt la chaîne pour s’assurer que chaque caractère est une lettre majuscule.
3- Si toutes les conditions sont respectées, elle retourne Vrai, sinon elle retourne Faux.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction verif_cle(ch:chaine):booleen Si (5 <= long(ch) <= 10) et (verif_distinct(ch)) alors i <- 0 # Vérifier que tous les caractères sont des lettres majuscules Tant que (i < long(ch) - 1) et ('A' <= ch[i] <= 'Z') faire i <- i + 1 Fin tant que retourner ('A' <= ch[i] <= 'Z') Sinon return Faux Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_cle
Cette fonction assure la saisie contrôlée d’une clé de cryptage valide en répétant la saisie jusqu’à obtention d’une clé conforme aux critères définis.
1- Elle demande à l’utilisateur de saisir une clé.
2- Elle vérifie la validité de cette clé à l’aide de la fonction verif_cle.
3- Tant que la clé saisie est invalide, elle redemande une nouvelle saisie.
4- Dès qu’une clé valide est fournie, elle la retourne.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction saisie_cle():chaine # Première saisie de la clé Ecrire('donner un cle valide: ') Lire(cle) # Tant que la clé n'est pas valide, on redemande Tant que Non(verif_cle(cle)) faire Ecrire('donner un cle valide: ') Lire(cle) Fin tant que # Retourne la clé valide retourner cle Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| cle | chaîne |
La procédure remplir_fichier_source
Cette procédure crée et remplit le fichier source en enregistrant un nombre donné de lignes saisies par l’utilisateur.
1- Elle ouvre (ou crée) le fichier Source.txt en mode écriture.
2- Elle demande à l’utilisateur de saisir n lignes de texte.
3- Chaque ligne saisie est écrite dans le fichier suivie d’un retour à la ligne.
4- Elle ferme le fichier à la fin de l’opération.
|
1 2 3 4 5 6 7 8 9 10 |
Procedure remplir_fichier_source(n:entier) Ecrire('*** Remplir fichier Source.txt ***') Ouvrir(f , "Source.txt", "w") # Saisie de n lignes et écriture dans le fichier Pour i de 0 à n-1 faire Ecrire('donner une ligne: ') Lire(ch) f.write(ch + '\n') f.close() Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
| i | entier |
| f | fichier |
La procédure remplir_matrice
Cette procédure transforme une ligne de texte en une matrice de caractères de dimensions adaptées à la clé, en complétant le message par des espaces si nécessaire.
1- Elle complète la ligne par des espaces si sa longueur n’est pas un multiple de la longueur de la clé.
2- Elle calcule le nombre de lignes réellement utilisées dans la matrice.
3- Elle place ensuite les caractères de la ligne ligne par ligne dans la matrice M.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Procedure remplir_matrice(m:matrice, long_cle:entier, ligne:chaine) # Compléter la ligne par des espaces pour qu'elle soit # multiple de la longueur de la clé Tant que (k mod long_cle != 0) faire k <- k + 1 ligne <- ligne + ' ' Fin tant que # Calcul du nombre de lignes utiles dans la matrice nbr_lignes <- k div long_cle k <- 0 # Remplissage de la matrice ligne par ligne Pour i de 0 à nbr_lignes-1 faire Pour j de 0 à long_cle) faire m[i][j] <- ligne[k] k <- k + 1 Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| k | entier |
| ligne | chaîne |
| k | entier |
| i | entier |
| j | entier |
La procédure afficher_matrice
Cette procédure affiche à l’écran les éléments de la matrice de caractères ligne par ligne.
1- Elle parcourt la matrice selon le nombre de lignes l et de colonnes c.
2- Elle affiche chaque caractère de la matrice avec un espace entre les éléments.
3- Elle passe à la ligne après l’affichage de chaque ligne de la matrice.
|
1 2 3 4 5 6 7 8 9 |
Procedure afficher_matrice(m:matrice, l:entier, c:entier) Ecrire('*** Contenu de la matrice M ***') Pour i de 0 à l-1 faire Pour j de 0 à c-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 crypter
Cette fonction effectue le cryptage du message en lisant la matrice colonne par colonne et en intégrant la clé afin de produire le message chiffré.
1- Elle parcourt la matrice colonne par colonne.
2- Pour chaque colonne, elle ajoute d’abord le caractère correspondant de la clé.
3- Ensuite, elle concatène les caractères de la colonne de haut en bas.
4- Elle construit ainsi progressivement la chaîne message_crypte.
|
1 2 3 4 5 6 7 8 9 10 11 |
Fonction crypter(m:matrice, l:entier, c:entier, cle:chaine) message_crypte <- '' # Parcours colonne par colonne Pour j de 0 à c-1 faire message_crypte <- message_crypte + cle[j] Pour i de 0 à l-1 faire message_crypte <- message_crypte + m[i][j] Fin pour Fin pour retourner message_crypte Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| message_crypte | chaîne |
La procédure crypter_fichier
Cette fonction effectue le cryptage du message en lisant la matrice colonne par colonne et en intégrant la clé afin de produire le message chiffré.
1- Elle parcourt la matrice colonne par colonne.
2- Pour chaque colonne, elle ajoute d’abord le caractère correspondant de la clé.
3- Ensuite, elle concatène les caractères de la colonne de haut en bas.
4- Elle construit ainsi progressivement la chaîne message_crypte.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Procédure crypter_fichier(m:matrice, long_cle:chaine) Ouvrir(f_source , "Source.txt", "r") Ecrire('*** Contenu fichier Crypt.txt ***') Ouvrir(f_crypt , "Crypt.txt", "w") # Lecture de toutes les lignes du fichier source message <- Lire_lignes(f_source) Pour ligne dans message faire ligne <- ligne.strip('\n') # Supprimer le retour à la ligne remplir_matrice(m, long_cle, ligne) afficher_matrice(m, nbr_lignes, len(cle)) # Cryptage de la ligne message_crypte <- crypter(m, nbr_lignes, len(cle), cle) # Écriture et affichage du message crypté Ecrire(f_crypt, message_crypte + '\n') ecrire(message_crypte) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_source | fichier |
| f_crypt | fichier |
| message | chaîne |
| message_crypte | chaîne |
| ligne | chaîne |
| nbr_ligenes | 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 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 50 # Nombre maximal de lignes colonnes = 50 # Nombre maximal de colonnes # Création d'une matrice M de taille 50x50 # Elle servira à stocker temporairement les caractères du message m = array([[str()] * colonnes] * lignes) # Création d'un tableau T de 50 dictionnaires # (non utilisé dans ce programme, probablement prévu pour une extension) t = array([{}] * 50) # -------------------------------------------------- # Fonction qui permet de saisir un entier strictement positif # correspondant au nombre de lignes du fichier source # -------------------------------------------------- def saisie_lignes(): # Première saisie du nombre de lignes n = int(input('donner le nombre des lignes : ')) # Tant que n est inférieur ou égal à 0, on redemande la saisie while (n <= 0): n = int(input('donner le nombre des lignes : ')) # Retourne le nombre de lignes valide return n # -------------------------------------------------- # Fonction qui vérifie que tous les caractères d'une chaîne # sont distincts (aucune répétition) # -------------------------------------------------- def verif_distinct(ch): c = ch[0] # Premier caractère ch = ch[1:len(ch)] # Reste de la chaîne # Tant que le caractère n'est pas trouvé dans le reste # et que la chaîne n'est pas vide while (ch.find(c) == -1) and (len(ch) != 0): c = ch[0] ch = ch[1:len(ch)] # Retourne True si aucun caractère répété return (ch.find(c) == -1) # -------------------------------------------------- # Fonction qui vérifie la validité de la clé # Conditions : # - longueur entre 5 et 10 # - caractères distincts # - uniquement des lettres majuscules # -------------------------------------------------- def verif_cle(ch): if (5 <= len(ch) <= 10) and (verif_distinct(ch)): i = 0 # Vérifier que tous les caractères sont des lettres majuscules while (i < len(ch) - 1) and ('A' <= ch[i] <= 'Z'): i = i + 1 return ('A' <= ch[i] <= 'Z') else: return False # -------------------------------------------------- # Fonction qui permet de saisir une clé valide # -------------------------------------------------- def saisie_cle(): # Première saisie de la clé cle = input('donner un cle valide: ') # Tant que la clé n'est pas valide, on redemande while not(verif_cle(cle)): cle = input('donner un cle valide: ') # Retourne la clé valide return cle # -------------------------------------------------- # Procédure qui crée et remplit le fichier Source.txt # -------------------------------------------------- def remplir_fichier_source(n): print('*** Remplir fichier Source.txt ***') f = open("Source.txt", "w") # Saisie de n lignes et écriture dans le fichier for i in range(n): ch = input('donner une ligne: ') f.write(ch + '\n') f.close() # -------------------------------------------------- # Procédure qui remplit la matrice M à partir d'une ligne # en complétant par des espaces si nécessaire # -------------------------------------------------- def remplir_matrice(m, long_cle, ligne): global nbr_lignes k = len(ligne) # Compléter la ligne par des espaces pour qu'elle soit # multiple de la longueur de la clé while (k % long_cle != 0): k = k + 1 ligne = ligne + ' ' # Calcul du nombre de lignes utiles dans la matrice nbr_lignes = k // long_cle k = 0 # Remplissage de la matrice ligne par ligne for i in range(nbr_lignes): for j in range(long_cle): m[i][j] = ligne[k] k = k + 1 # -------------------------------------------------- # Procédure qui affiche le contenu de la matrice M # -------------------------------------------------- def afficher_matrice(m, l, c): print('*** Contenu de la matrice M ***') for i in range(l): for j in range(c): print(m[i][j], end=' ') print() # -------------------------------------------------- # Fonction qui effectue le cryptage par colonnes # en utilisant la clé # -------------------------------------------------- def crypter(m, l, c, cle): message_crypte = '' # Parcours colonne par colonne for j in range(c): message_crypte = message_crypte + cle[j] for i in range(l): message_crypte = message_crypte + m[i][j] return message_crypte # -------------------------------------------------- # Procédure qui crypte le fichier Source.txt # et écrit le résultat dans Crypt.txt # -------------------------------------------------- def crypter_fichier(m, long_cle): global nbr_lignes f_source = open("Source.txt", "r") print('*** Contenu fichier Crypt.txt ***') f_crypt = open("Crypt.txt", "w") # Lecture de toutes les lignes du fichier source message = f_source.readlines() for ligne in message: ligne = ligne.strip('\n') # Supprimer le retour à la ligne remplir_matrice(m, long_cle, ligne) afficher_matrice(m, nbr_lignes, len(cle)) # Cryptage de la ligne message_crypte = crypter(m, nbr_lignes, len(cle), cle) # Écriture et affichage du message crypté f_crypt.write(message_crypte + '\n') print(message_crypte) f_source.close() f_crypt.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- nbr_lignes = 0 # Nombre de lignes réelles de la matrice cle = saisie_cle() # Saisie de la clé n = saisie_lignes() # Saisie du nombre de lignes remplir_fichier_source(n) # Création du fichier source crypter_fichier(m, len(cle)) # Cryptage du fichier |
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
