REPUBLIQUE DU CAMEROUN FACULTE DES SCIENCES

REPUBLIC OF CAMEROON FACULTY OF SCIENCE

Peace-Work-FatherLand
********
UNIVERSITE DE DSCHANG
UNIVERSITY OF DSCHANG
Scholae Thesaurus Dschangensis Ibi Cordum
BP 96, Dschang (Cameroun)
Tél./Fax (237) 233 45 13 81
Website : http://www.univ-dschang.org.
E-mail : udsrectorat@univ-dschang.org
Department de Mathématiques et
Informatique
Department of mathematics and Computer
Science
BP 96, Dschang (Cameroun)
Tél./Fax (237) 233 45 13 81
Website : http://fs.univ-dschang.org.
E-mail : dept.math-info@univ-dschang.org

PROJET DE CRYPTOGRAPHIE : CODAGE PAR

TRANSPOSITION

Noms et prénoms des membres du groupe Matricules

NGOUNOU TCHUINTEU Patricia Ornella CM-UDS-18SCI2322
KENGNE WAMBO DARIL RAOUL CM-UDS-18SCI0131
TEMFACK DERICK CM-UDS-18SCI0797

Enseignant : Dr. Géraud FOKOU PELAP

Année Scolaire 2019/2020

 SOMMAIRE
INTRODUCTION
I. CODAGE ET DECODAGE DES TEXTES
II. ANALYSE DU TEMPS DE CODAGE ET DE DECODAGE
CONCLUSION
CODE DU PROGRAMME
 INTRODUCTION

Le chiffrement par transposition (ou par permutation) est un chiffrement qui

consiste à changer l’ordre des lettres, donc à construire des anagrammes. Cette
méthode est connue depuis l’antiquité avec la scytale spartiate.
Le chiffrement par transposition demande de découper le texte clair en blocs
de tailles identiques, de le placer en ligne dans un matrice puis de constituer le
code en faisant une lecture en colonne tout en changeant les espaces par des
carrés (au codage et en réalisant l’opération inverse au décodage) ; ceci se
faisant pour le codage et le décodage.
En effet, pour implémenter ce chiffrement par transposition à l’aide du langage
java, nous avons utilisé le principe suivant pour le codage :
 Pour chaque ligne du texte, l’on la remplie chacune dans une matrice de
taille la clef donnée.
 Dans chacune des matrices, on lit colonne par colonne et on concatène
le résultat.
 On concatène les différents résultats obtenus par concaténation des
matrices dans l’ordre initial des lignes du texte.
Il est à noter qu’à chaque fois dans le deuxième point, lors de la lecture du
caractère espace, celui-ci est remplacé par un carré (¤).
Aussi, pour obtenir le principe de départ, selon lequel le texte doit être divisé
en bloc, il suffit de tenir le texte sur une seule ligne (en occurrence avec
bloc note) ; ce qui n’inféra pas dans la lecture du message lors du décodage
en dépit du nouveau formatage du texte clair (le but recherché étant que le
texte décodé soit le même en termes de sème).
Par ailleurs, pour le décodage, il suit les étapes suivantes :
 On compte pour chaque ligne du code, le nombre de caractères puis
on en déduit le nombre de colonnes de la matrice qui servira à
remplir le code de la ligne en divisant le nombre de caractère par la
clef.
 Ensuite on insère chaque ligne chacune dans une matrice
correspondante ligne par ligne.
  Enfin, pour chaque matrice, le contenue est concaténé et rangé sur
des lignes suivant l’ordre dans le code ; ce qui permet d’obtenir le
texte en clair.

I. TEST DES PROGRAMMES DE CODAGE DE DECODAGE

Les images suivantes permettent de mettre en évidence le codage sur un
ensemble de textes arbitrairement choisit.

Premier exemple
 Second exemple

II. ANALYSE DU TEMPS D’EXECUTION

En prenant comme texte de référence le texte introductif du cours, l’on met ici
en évidence le temps d’exécution du codage et du décodage en fonction de
différentes clefs.
On remarque que les clefs étant petites, le temps de codage et de décodage
sont presque stagnants. Ainsi, dans le but d’avoir une évolution plus visible, en
plus des clefs 5, 10, et 15, l’on a évalué ces opérations avec les clefs 50, 180,
350,1000 et 9000.
Ces opérations étant réalisée sur un core i5 (2Go de RAM), on obtient :
 Codage et décodage avec la clef 5

Codage et décodage avec la clef 10

Codage et décodage avec le clef 30

Codage et décodage avec la clef 50

Codage et décodage avec la clef 180

Codage et décodage avec la clef 350

 Codage et décodage avec la clef 1000

Codage et décodage avec la clef 9000

 Données du codage
Taille de
5 10 30 50 180 350 1000 9000
matrice
Temps
d’exécution 20 21 25 27 31 52 88 806
en ms

GRAPHE ASSOCIE AU CODAGE

Courbe de l'évolution du temps d’exécution (en ms)

du codage en fonction de la taille de la matrice
900
800
700
600
500
400
300
200
100
0
5 10 30 50 180 350 1000 9000
Taille de matrice
Temps d’exécution
en ms
Taille de la
5 10 30 50 180 350 1000 9000
matrice

Temps
d’exécution 21 21 22 25 28 30 41 911
En ms

Données de décodage

GRAPHE ASSOCIE AU DECODAGE

Courbe de l'évolution du temps d’exécution (en

ms) du décodage en fonction de la taille de la
matrice
900
800
700
600
500
400 Temps d’exécution en
300
ms
200
100
0
5 10 30 50 180 350 1000 9000
Taille de matrice
 Conclusion
Au terme de cette analyse où il était question de présenter le codage et le
décodage du chiffrement par transposition ainsi que des durées de codage et
de décodage en fonction du temps, il en ressort que, plus la taille de la
matrice(clef) est grandissante, plus le temps mis pour les opérations de codage
et de décodage grandit. Ainsi au moyen âge, ce code pouvait avoir une
efficacité justifiée car les supers calculateurs existant aujourd’hui n’avaient
encore vu le jour.
 CodageTransposition.java

1 package tp.crypto.codageTransposition;
2
3 import java.io.BufferedReader;
8
9 public class CodageTransposition {
10 public static void main(String[] args) {
11
12 codage("message.txt", 15); // message.txt est le fichier texte où se trouve le
texte à coder
13 long start = System.currentTimeMillis();
14 decodage("code.txt", 15); // code.txt est le fichier texte où est mis le code
obtenue
15 long end = System.currentTimeMillis();
16
17 System.out.println("Le temps de codage de ce message avec la clef 5 est " + (end -
start) + " ms");
18
19 }
20
21 public static void codage(String messageACoder, int clef) {
22
23 try (BufferedReader br = new BufferedReader(new FileReader(messageACoder));
24 BufferedWriter bw = new BufferedWriter(new FileWriter("code.txt"))) {
25
26 String ligne;
27 while ((ligne = br.readLine()) != null) { // on recupere ligne après ligne dans
le fichier
28
29 // -----------------------calcul du nombre de ligne de la matrice en
fonction du
30 // nombre de caractère de la
31 // ligne et de la clef
32
33 int nbreDeLigneMatrice = nbreLigneMatrice(ligne.length(), clef);
34
35 char[] ligneTab = ligne.trim().toCharArray(); // effacement des espaces
36 char[][] matrice = new char[nbreDeLigneMatrice][clef];
37
38 int i = 0, j = 0, k = 0;
39 while (i < nbreDeLigneMatrice) { // on parcourt le tableau en ligne
40 j = 0;
41 while (j < clef && k < ligneTab.length) { // on ne s'arrête de copier
dans la ligne que si
42
43 // l'on a tout lu la ligne récupérée ou alors si l'on est en fin de
44 // ligne du tableau
45
46 if (ligneTab[k] == ' ') // quand on retrouve l'espace, on le
remplace par le carré
47
48 matrice[i][j] = (char) 164; // 164 represente le carré en code
ASCII
49
50 else // dans le caas contraire,on recopie normalement des
caractères
51
52 matrice[i][j] = ligneTab[k];
53
54 j++;
55 k++;
56 }
57 i++;

Page 1
 CodageTransposition.java

58 }
59
60 //-------------------------------------------------------------------------
------
61 // Completion des cases vides par des carre
62 for (int cpt = j; cpt < clef; cpt++) {
63 matrice[nbreDeLigneMatrice - 1][cpt] = (char) 164; // 164 represente le
carre dans le code ASCII
64 }
65
66 // Lecture de la matrice et reconstitution du code de la ligne dans un
String
67 //ceci se faisant en lisant la matrice colone par colone
68
69 String message = "";
70 for (int p = 0; p < clef; p++) {
71 for (int q = 0; q < nbreDeLigneMatrice; q++) {
72 message += matrice[q][p];
73 }
74
75 }
76
77 // Ecriture de la ligne codée dans le fichier de reponse
78 bw.write(message);
79 bw.newLine();
80
81 }
82 } catch (IOException e) {
83 e.printStackTrace();
84 }
85
86 }
87
88 public static void decodage(String messageADeCoder, int clef) {
89
90 try (BufferedReader br = new BufferedReader(new FileReader(messageADeCoder));
91 BufferedWriter bw = new BufferedWriter(new FileWriter("messageclair.txt")))
{
92
93 String code; // ligne du fichier codé
94 String texteClair = "";
95
96 while ((code = br.readLine()) != null) { //-----------lecture en ligne du
fichier
97
98 texteClair = decrypte(code, clef); //decodage de la ligne lue
99
100 bw.write(texteClair); //ecriture de la ligne décodée dans le fichier
contenant le texte clair
101 bw.newLine();
102 }
103
104 } catch (IOException e) {
105 e.printStackTrace();
106 }
107
108 }
109
110 /**
111 * @param tailleMessage
112 * @param clef
113 * @return Retourne le nombre de ligne de la matrice de codage

Page 2
 CodageTransposition.java

114 */
115
116 //-------------------------------------------------------------------------------------
--------------------
117
118 /*
119 * cette donction permet de déterminer le nombre de ligne de la matrice de taille clef
120 * pouvant contenir un certain nombre de caratères appelé tailleMessage
121 *
122 */
123 private static int nbreLigneMatrice(int tailleMessage, int clef) {
124 if (tailleMessage % clef == 0) {//si la clef est multiple de la taille du message,
on fait une division entière
125 return tailleMessage / clef;
126 } else { //dans le cas contraire on ajoute une ligne de plus au quotient ce qui
permettre de contenir le reste de
127 //caractères et des espaces
128 return (tailleMessage / clef) + 1;
129 }
130 }
131
132 //-------------------------------------------------------------------------------------
-----------------------
133
134 /*
135 * Cette fontion decrypte permet de décrypter une ligne
136 */
137 public static String decrypte(String code, int cle) {
138 int taille = ((code.length()) / cle), longueur; //longueur stocke le nombre de
ligne
139 //------------------------------------------calcul du nombre de ligne
140 String texteClair = new String("");
141 if (((code.length()) % taille) == 0) {
142 longueur = (code.length()) / taille;
143 } else {
144 longueur = (code.length()) / taille + 1;
145 }
146
147 //-----------------------------------------------------------------
148
149
150 char[][] tab = new char[longueur][taille];
151 int i = 0, j = 0, k = 0;
152 while (i < longueur) { // insertion du message dans le tableau
153 j = 0;
154
155 while (j < taille && k < code.length()) {
156 if ((int) (code.charAt(k)) == 164) { //les espaces sont remis à leur
place
157 tab[i][j] = ' ';
158
159 j++;
160 k++;
161 } else {
162 tab[i][j] = code.charAt(k);
163 j++;
164 k++;
165 }
166 }
167 i++; //on avance la ligne
168
169 }

Page 3
 CodageTransposition.java

170
171 // ---------lecture de la matrice dans l'ordre inverse(en colone) dans le but de
d chiffrer
172 // le message
173
174 for (i = 0; i < taille; i++) {
175 for (j = 0; j < longueur; j++) {
176 texteClair += tab[j][i];
177 }
178 }
179
180 return texteClair.trim();
181
182 }
183
184 }
185

Page 4