-
Notifications
You must be signed in to change notification settings - Fork 0
/
main.cpp
223 lines (173 loc) · 8.77 KB
/
main.cpp
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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
#include <iostream>
#include <string.h>
#include "bitmapManager.h"
unsigned char permutationTable[256];
unsigned char cle[] = "Bonjour le monde, voici ma superbe clé";
/**
* Méthode permettant d'initialiser le contenu de notre table de permutation cette dernière contiendra 256 caractère (ascii étendu)
*
* On initialiser cette table avec des entiers successifs (1,2,3 ... 255)
* On parcourera ensuite cette table caractère par caractère. Chaque caractère sera permuté en fonction du contenu de notre clé.
*/
void initTablePermutation() {
int pointeurCle = 0; // La position du caractère qu'on va lire dans notre clé
int nombreCharCle = (int) strlen((const char *) cle); // Le nombre de caractère de notre clé
int tempoPermutationPosition; // Position temporaire qu'on va utilisé pour notre permutation
unsigned char tempoPermutationValue; // Valeur que l'on va permuté
int i; // Parceque sinon, c'est du C++ ;)
// Rmplissage la table de permutation avec toute les valeurs possibles d'un unsigned char
for (i = 0; i < 256; i++) {
permutationTable[i] = i;
}
// Permutation
for (i = 0; i < 256; i++) {
//stockage de la valeur du tableau actuelle
tempoPermutationPosition = cle[pointeurCle];
tempoPermutationValue = permutationTable[tempoPermutationPosition];
//permutation entre la position du compteur actuel et une position liée à la valeur de la clée
permutationTable[tempoPermutationPosition] = permutationTable[i];
permutationTable[i] = tempoPermutationValue;
//incrémentation de la valeur de la clé (si on dépasse le nombre de caractères de la clé, on retourne au début de la clé)
pointeurCle++;
// Si la clé n'a plus de caractère permettant la permutation on réinitialiser le pointeur au début de la taille de la clé
if (pointeurCle > nombreCharCle) {
pointeurCle = 0;
}
}
}
/**
* Fonction permettant de chiffrer un caractère avec notre table de permutation
*
* @param c
* @return
*/
unsigned char chiffrement(unsigned char c) {
return permutationTable[((int) c)];
}
/**
* Fonction permettant de chiffrer un caractère avec notre table de permutation
*
* @param c
* @return
*/
unsigned char deChiffrement(unsigned char c) {
unsigned char tempo;
for (int i = 0; i < 256; i++) {
if (permutationTable[i] == c) {
tempo = (unsigned char) i;
break;
}
}
return (int) tempo;
}
int main() {
// Taille de notre clé
int nombreCaractereCle = (int) strlen((const char *) cle);
//vecteur d'initialisation (on le remplira uniquement de 0 pour le moment
unsigned char *vecteurInitialisation;
vecteurInitialisation = (unsigned char *) malloc(sizeof(unsigned char) * nombreCaractereCle);
memset(vecteurInitialisation, 0, nombreCaractereCle);
//initialisation de la Table fe permutation
initTablePermutation();
// Ouverture du fichier (en lecture le texte à chiffrer, en écriture le texte de sauvegarde, pour le debug)
FILE *secretInputFile = fopen("..\\data\\secret.txt", "r");
char secretOutputPath[] = "..\\data\\secret_output.txt";
FILE *secretOutputFile = fopen(secretOutputPath, "w+");
//récupération du nombre de caractères pour le dernier bloc (on se place à la fin du fichier, on fait un modulo de la taille du buffer pour récupérer ce qu'il reste)
fseek(secretInputFile, 0, SEEK_END);
int nombreCaractereFichier = ftell(secretInputFile);
int sizeLastBlock = nombreCaractereFichier % nombreCaractereCle;
//création d'un buffer du contenu chiffré
unsigned char bufferChiffre[nombreCaractereFichier];
memset(vecteurInitialisation, 0, nombreCaractereCle);
// placement du pointeur au début du fichier à lire
fseek(secretInputFile, 0, SEEK_SET);
/**
* CHIFFREMENT ! ! !
*/
//buffer de lecture et variable du nombre de charactère lu
unsigned char buffer[nombreCaractereCle]; // buffer de lecture
int nbReadChar = 0; // nombre de caractères lus
int convert = 0; //conversion (permettra la réalisation du xor et du chiffrement et inversement)
int nombreBoucle = 0; // Nombre de boucle (pour n'utiliser le vecteur d'initialisation qu'une seule fois
int pointeurCaractereBufferChiffre = 0; // Permet de savoir dans quel emplacement on doit écrire dans le buffer chiffré
int posBufferWrite = 0; // Permet de connaitre la position du charactere du bloc précédent permettant le xor
//Lecture du fichier (par bloc égal au nombre de caractère de la clé)
while ((nbReadChar = fread(buffer, sizeof(unsigned char), nombreCaractereCle, secretInputFile))) {
//on va maintenant parcourrir le buffer remplis à partir du fichier
for (int i = 0; i < nbReadChar; i++) {
// Réalisation des trantement de type xor et chiffrement
// Traitement pour la première boucle (on n'a pas de bloc précédent, donc on utilise un vecteur d'initialisation)
if (nombreBoucle == 0) {
// XOR
convert = buffer[i] ^ vecteurInitialisation[i];
// Chiffrement
convert = chiffrement(convert);
// Traitement pour la seconde boucle et les suivantes
} else {
// Calcul de la position du caractère que l'on doit utiliser
posBufferWrite = ((nombreBoucle * nombreCaractereCle) + i) - nombreCaractereCle;
// XOR
convert = buffer[i] ^ bufferChiffre[posBufferWrite];
// Chiffrement
convert = chiffrement(convert);
}
// Ecriture dans le buffeur
bufferChiffre[pointeurCaractereBufferChiffre] = convert;
// Incrémentation du pointeur pour la prochaine écriture d'un caractère
pointeurCaractereBufferChiffre++;
}
//incrémentation du nombre de la boucle pour n'utiliser le vercteur d'initialisation qu'unse seule fois
nombreBoucle++;
// On remplis le buffer avec des 0 (non utilisé pour le moment)
//memset(buffer, (unsigned char) 0x00, sizeof(buffer));
};
//OPTIONNEL : Ecriture du contenu CHIFFRE dans "lorem_ipsum_chiffre.txt"
fwrite(bufferChiffre, sizeof(char), pointeurCaractereBufferChiffre, secretOutputFile);
//fermeture des File Descriptor (lecture et écriture)
fclose(secretInputFile);
fclose(secretOutputFile);
//TODO INTEGRER LA GESTION DE L'IMAGE ICI
//TODO ATTENTION : A PARTIR DE CE MOMENT, LA VARIABLES CHIFFREE EST : bufferChiffre
//TODO La TAILLE de bufferChiffre EST : nombreCaractereFichier
/**
* Add secrets to bitmap image
*/
char bitmapPath[] = "..\\data\\tiger.bmp";
char outputBitmapPath[] = "..\\data\\tiger_edited.bmp";
BitmapManager bmpFileEncrypt(bitmapPath);
bmpFileEncrypt.encryptSecrets(bitmapPath, secretOutputPath, outputBitmapPath);
/**
* DECHIFFREMENT
*/
/**
* Read secrets from bitmap image
*/
char decryptBitmapPath[] = "..\\data\\secret_decrypt.txt";
BitmapManager bmpFileDecrypt(outputBitmapPath);
bmpFileDecrypt.decryptSecrets(outputBitmapPath, decryptBitmapPath);
//OPTIONNEL : On écrira également le contenu DECHIFFRE dans "lorem_ipsum_dechiffre.txt"
secretOutputFile = fopen(decryptBitmapPath, "w+");
//création d'un buffer du contenu déchiffré
unsigned char bufferDechiffre[nombreCaractereFichier];
memset(bufferDechiffre, 0, nombreCaractereCle);
for (int i = 0; i < nombreCaractereFichier; i++) {
// Déchiffrement du caractère
convert = deChiffrement(bufferChiffre[i]);
// réalisation du XOR pour le premier bloc se basant sur un vecteur d'initialisation(l'inverse d'un XOR est un XOR)
if (i < nombreCaractereCle) {
convert = convert ^ vecteurInitialisation[i];
}
// réalisation du XOR avec le contenu du bloc précédent lorsqu'on est au second bloc ou plus (l'inverse d'un XOR est un XOR)
else {
convert = convert ^ bufferChiffre[(i - nombreCaractereCle)];
}
bufferDechiffre[i] = convert;
}
//OPTIONNEL : Ecriture du contenu DECHIFFRE dans "lorem_ipsum_dechiffre.txt" et fermeture de ce dernier
fwrite(bufferDechiffre, sizeof(char), nombreCaractereFichier, secretOutputFile);
fclose(secretOutputFile);
//TODO LE CONTENU DECHIFFRE SE TROUVE DANS LA VARIABLE bufferDechiffre
//TODO LA TAILLE DE bufferDechiffre EST nombreCaractereFichier
return (0);
}