Sujet de cryptage – Bac théorique – Section informatique – 2017
Sujet (Algo et programmation - Bac 2017)
La stéganographie est une méthode qui consiste à cacher un texte dans une image numérique bitmap. Cette méthode peut aider à échanger des messages secrets.
Dans une image RVB, chaque pixel est représenté par une chaîne de 6 chiffres hexadécimaux ; les deux premiers représentent l'intensité de la couleur "Rouge", les deux suivants celle de la couleur "Vert" et les deux derniers représentent l'intensité de la couleur "Bleu".
On se propose d'utiliser cette technique pour crypter un texte. Pour cela on dispose d'un fichier texte à crypter nommé "source.txt" situé sur la racine du disque C et comportant N lignes non vides (1 < N < 40) de longueur maximale 120 caractères chacune.
Le procédé de cryptage est décrit ci-dessous :
1- générer une matrice carrée M (40x40) à partir du fichier "source.txt" comme suit :
- initialiser les cases de la matrice par le code de la couleur blanche "FFFFFF"
- remplir chaque ligne de la matrice M par une ligne du fichier "source.txt" de la manière suivante :
ajouter à la fin de la ligne, si c'est nécessaire, un ou deux espaces pour que sa longueur soit divisible par trois
subdiviser la ligne en blocs de trois caractères consécutifs et remplir chaque case de la matrice par la chaîne résultante de la concaténation des équivalents hexadécimaux du code ASCII des trois caractères de chaque bloc
2- générer un fichier "code.txt" à partir de la matrice M, où chaque ligne du fichier correspond à la concaténation du contenu d'une colonne de la matrice.
En effet :
- la matrice M a été initialisée par le code de la couleur blanche "FFFFFF"
- la première ligne de la matrice M est remplie à partir de la première ligne du fichier "source.txt" comme suit :
- étant donné que la longueur de la première ligne du fichier "source.txt" est non divisible par 3, on ajoute un espace à la fin pour obtenir 4 groupements de 3 caractères consécutifs :
le premier élément de la matrice 1V111,11 est égal à "424143" car :
- le code ASCII de "B" est 66 et son équivalent hexadécimal est 42
- le code ASCII de "A" est 65 et son équivalent hexadécimal est 41
- le code ASCII de "C" est 67 et son équivalent hexadécimal est 43 la concaténation des 3 équivalents hexadécimaux donne "424143" d'où le contenu de M[1,11= "424143"
- le même procédé donne M[1,2] = "205349", M11,31= "203230" et M[1,4] = "313620"
les autres lignes de la matrice M sont remplies selon le même procédé.
D'où, en concaténant les valeurs de chaque colonne de la matrice M pour former une ligne du fichier, on obtient le fichier "code.txt" ci-dessous :
Travail demandé :
I - Analyser le problème en le décomposant en modules.
2- Ecrire un algorithme solution pour chaque module envisagé. Chaque algorithme proposé doit être accompagné d'un tableau de déclaration des objets
Solution Algorithmique
Dans cet algorithme, On va utiliser trois fonctions et quatre procédures:
- la fonction saisie_lignes()
- la fonction saisie_ch()
- la procédure remplir_fichier_source()
- la procédure initialiser_matrice()
- la fonction convert_hexa()
- la procédure remplir_matrice()
- la procédure remplir_fichier_code()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 |
Algorithme Cryptage Debut n <- saisie_lignes() # Saisie du nombre de lignes remplir_fichier_source(n) # Création du fichier Source.txt initialiser_matrice(m) # Initialisation de la matrice remplir_matrice(m) # Remplissage de la matrice remplir_fichier_code(m) # Création du fichier code.txt Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| m | matrice |
La fonction saisie_lignes
Cette fonction permet de demander à l’utilisateur de saisir un nombre entier représentant le nombre de lignes, en s’assurant que cette valeur est strictement comprise entre 1 et 40.
1- Elle lit une valeur entière saisie au clavier.
2- Elle vérifie la validité de cette valeur.
3- Tant que le nombre saisi n’est pas compris entre 1 et 40, la saisie est redemandée.
4- Elle retourne finalement un entier valide, utilisable comme nombre de lignes du fichier source.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie_lignes():entier # Saisie initiale Ecrire('donner le nombre des lignes entre 1 et 40 : ') Lire(n) # Vérification de la validité de la saisie Tant que Non (1 <= n <= 40) faire Ecrire('donner le nombre des lignes entre 1 et 40 : ') Lire(n) Fin pour # Retourner le nombre valide retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie_ch
Cette fonction permet de saisir une chaîne de caractères valide, dont la longueur est comprise entre 1 et 120 caractères.
1- Elle demande à l’utilisateur de saisir une chaîne.
2- Elle vérifie que la longueur de la chaîne respecte l’intervalle autorisé [1,120].
3- Tant que la chaîne est vide ou dépasse 120 caractères, la saisie est redemandée.
4- Elle retourne la chaîne correcte, prête à être utilisée par le programme.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction saisie_ch():chaine # Saisie de la chaîne Ecrire('donner une chaine : ') Lire(ch) # Vérification de la longueur de la chaîne Tant que Non (1 <= long(ch) <= 120) faire Ecrire('donner une chaine : ') Lire(ch) Fin si # Retourner la chaîne valide retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La procédure remplir_fichier_source
Cette procédure permet de créer et remplir le fichier texte Source.txt avec n lignes de texte 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 chaînes de caractères, chacune représentant une ligne du fichier.
3- Chaque chaîne saisie est écrite dans le fichier suivie d’un retour à la ligne.
4- Elle ferme le fichier après la fin de l’écriture.
|
1 2 3 4 5 6 7 8 9 |
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 ch <- saisie_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 initialiser_matrice
Cette procédure permet d’initialiser la matrice m de dimension 40 × 40 en affectant à toutes ses cases la valeur "FFFFFF".
1- Elle parcourt la matrice ligne par ligne et colonne par colonne.
2- Pour chaque élément m[i][j], elle attribue la chaîne "FFFFFF".
3- Elle garantit que la matrice est totalement remplie avec une valeur par défaut avant toute autre utilisation.
|
1 2 3 4 5 6 7 |
Procedure initialiser_matrice(m:matrice) Pour i de 0 à 39 faire Pour j de 0 à 39 faire m[i][j]="FFFFFF" Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La fonction convertir_hexadecimal
Cette fonction a pour rôle de convertir un nombre décimal (base 10) en un nombre hexadécimal (base 16) en utilisant la méthode de conversion manuelle.
1- Elle divise successivement le nombre par 16.
2- À chaque étape, elle récupère le reste, qui correspond à un chiffre hexadécimal.
3- Comme l’hexadécimal utilise 16 symboles (0–9 et A–F), la fonction récupère le bon caractère dans la chaîne :"0123456789ABCDEF"
4- Chaque caractère obtenu est ajouté à gauche pour construire correctement le nombre hexadécimal.
5- La conversion s’arrête lorsque le nombre devient 0.
|
1 2 3 4 5 6 7 8 |
fonction convertir_hexadecimal(n:entier):chaine hexa <- "" caracteres <- "0123456789ABCDEF" # Table des symboles hexadécimaux Tant que n > 0 faire reste <- n lod 16 # Reste en base 16 hexa <- caracteres[reste] + hexa # Ajout du caractère correspondant n <- n div 16 # Division entière par 16 retourner hexa |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| hexa | chaine |
| caracteres | chaine |
| reste | entier |
La procédure remplir_matrice
Cette procédure permet de remplir la matrice m à partir du contenu du fichier Source.txt, en convertissant chaque groupe de 3 caractères en un code hexadécimal.
1- Elle ouvre le fichier Source.txt en mode lecture.
2- Elle lit toutes les lignes du fichier, chaque ligne correspondant à une ligne de la matrice.
- Pour chaque ligne, elle supprime le caractère de fin de ligne et complète la chaîne par des espaces afin que sa longueur soit un multiple de 3.
- Elle découpe la chaîne en blocs de 3 caractères.
3- Pour chaque bloc :
Chaque caractère est converti en code hexadécimal (via la fonction convert_hexa appliquée au code ASCII du caractère).
Les codes hexadécimaux obtenus sont concaténés.
Le résultat est stocké dans la matrice m à la position correspondante.
4- Enfin, elle ferme le fichier source.
|
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 |
Procedure remplir_matrice(m:matrice) # Ouverture du fichier source en lecture Ouvrir(f_source , "Source.txt", "r") # Lecture de toutes les lignes du fichier lignes <- f_source.readlines() i <- -1 # Parcours des lignes du fichier Pour ligne dans lignes faire i <- i + 1 ch <- ligne.strip('\n') # Suppression du retour à la ligne # Compléter la chaîne pour que sa longueur # soit un multiple de 3 Tant que long(ch) mod 3 != 0 alors ch <- ch + ' ' Fin tant que # Découpage de la chaîne en blocs de 3 caractères Pour j de 0 à long(ch) div 3)-1 faire ch1 <- Sous_chaine(ch,j*3 , j*3 + 3] elt <- "" # Conversion de chaque caractère en hexadécimal Pour k de 0 à long(ch1)-1 faire elt <- elt + convert_hexa(ord(ch1[k])) Fin pour # Stockage du résultat dans la matrice m[i][j] <- elt Fin pour Fin pour # Fermeture du fichier source Fermer(f_source) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_source | chaîne |
| lignes | chaîne |
| ligne | chaîne |
| i | entier |
| j | entier |
| ch1 | chaîne |
| elt | chaîne |
La procédure remplir_fichier_code
Cette procédure permet d’écrire le contenu de la matrice M dans le fichier texte code.txt tout en l’affichant simultanément à l’écran.
1- Elle ouvre (ou crée) le fichier code.txt en mode écriture.
2- Elle parcourt la matrice M de dimension 40 × 40.
3- Pour chaque élément m[i][j] :
La valeur est écrite dans le fichier code.txt.
La même valeur est affichée à l’écran, séparée par un espace.
Après chaque ligne de la matrice, un retour à la ligne est effectué à l’écran.
4- Enfin, elle ferme le fichier pour sauvegarder les données.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Procedure remplir_fichier_code(m:matrice) Ecrire('*** Contenu du fichier code.txt ***') # Ouverture du fichier en mode écriture Ouvrir(f_code , "code.txt", "w") # Parcours de la matrice Pour i de 0 à 39 faire Pour j de 0 à 39 faire Ecrire(f_code , (m[i][j]) Ecrire(m[i][j], ' ') Fin pour Ecrire() Fin pour # Fermeture du fichier Fermer(f_code) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_code | chaîne |
| i | entier |
| j | 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 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 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 50 # Nombre maximal de lignes de la matrice colonnes = 50 # Nombre maximal de colonnes de la matrice # Création d'une matrice M de taille 50x50 # Elle servira à stocker les codes hexadécimaux du message m = array([[str] * colonnes] * lignes) # -------------------------------------------------- # Fonction qui permet de saisir un entier # strictement compris entre 1 et 40 # (nombre de lignes du fichier source) # -------------------------------------------------- def saisie_lignes(): # Saisie initiale n = int(input('donner le nombre des lignes entre 1 et 40 : ')) # Vérification de la validité de la saisie while not (1 <= n <= 40): n = int(input('donner le nombre des lignes entre 1 et 40 : ')) # Retourner le nombre valide return n # -------------------------------------------------- # Fonction qui permet de saisir une chaîne # de longueur comprise entre 1 et 120 caractères # -------------------------------------------------- def saisie_ch(): # Saisie de la chaîne ch = input('donner une chaine : ') # Vérification de la longueur de la chaîne while not (1 <= len(ch) <= 120): ch = input('donner une chaine : ') # Retourner la chaîne valide return ch # -------------------------------------------------- # Procédure qui crée et remplit le fichier Source.txt # avec n lignes saisies par l'utilisateur # -------------------------------------------------- def remplir_fichier_source(n): print('*** Remplir fichier Source.txt ***') # Ouverture du fichier en mode écriture f = open("Source.txt", "w") # Saisie et écriture des n lignes for i in range(n): ch = saisie_ch() f.write(ch + '\n') # Fermeture du fichier f.close() # -------------------------------------------------- # Procédure qui initialise la matrice M # avec la valeur "FFFFFF" # -------------------------------------------------- def initialiser_matrice(m): for i in range(40): for j in range(40): m[i][j] = "FFFFFF" # -------------------------------------------------- # Fonction qui convertit un entier décimal # en une chaîne hexadécimale # -------------------------------------------------- def convert_hexa(n): hexa = "" caracteres = "0123456789ABCDEF" # Symboles hexadécimaux # Conversion décimal → hexadécimal while n > 0: reste = n % 16 hexa = caracteres[reste] + hexa n = n // 16 return hexa # -------------------------------------------------- # Procédure qui remplit la matrice M à partir # du contenu du fichier Source.txt # Chaque groupe de 3 caractères est transformé # en code hexadécimal # -------------------------------------------------- def remplir_matrice(m): # Ouverture du fichier source en lecture f_source = open("Source.txt", "r") # Lecture de toutes les lignes du fichier lignes = f_source.readlines() i = -1 # Parcours des lignes du fichier for ligne in lignes: i += 1 ch = ligne.strip('\n') # Suppression du retour à la ligne # Compléter la chaîne pour que sa longueur # soit un multiple de 3 while len(ch) % 3 != 0: ch = ch + ' ' # Découpage de la chaîne en blocs de 3 caractères for j in range(len(ch) // 3): ch1 = ch[j*3 : j*3 + 3] elt = "" # Conversion de chaque caractère en hexadécimal for k in range(len(ch1)): elt = elt + convert_hexa(ord(ch1[k])) # Stockage du résultat dans la matrice m[i][j] = elt # Fermeture du fichier source f_source.close() # -------------------------------------------------- # Procédure qui écrit le contenu de la matrice M # dans le fichier code.txt et l'affiche à l'écran # -------------------------------------------------- def remplir_fichier_code(m): print('*** Contenu du fichier code.txt ***') # Ouverture du fichier en mode écriture f_code = open("code.txt", "w") # Parcours de la matrice for i in range(40): for j in range(40): f_code.write(m[i][j]) print(m[i][j], end=' ') print() # Fermeture du fichier f_code.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie_lignes() # Saisie du nombre de lignes remplir_fichier_source(n) # Création du fichier Source.txt initialiser_matrice(m) # Initialisation de la matrice remplir_matrice(m) # Remplissage de la matrice remplir_fichier_code(m) # Création du fichier code.txt |
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
