Discussion :

[jamesb]

Bonjour à tous,

J'essaie de chiffrer un fichier à l'aide d'une clé et de l'opération xor sur tout le fichier. Bien entendu la clé est plus petite que le fichier à chiffrer du coup la clé est parcourue en boucle.

Cependant j'ai un petit problème au niveau du déchiffrage, le programme se lance mais quitte directement sans rien faire. On dirait qu'il plante et il y a une erreur mémoire (instruction xxx ... impossible de read)

J'ai peut-être commis une erreur dans le chiffrage puisque je suis totalement novice en chiffrage et en C++ en plus. D'après ce que j'ai compris je peux utiliser la même opération que le chiffrage, au niveau du xor, pour déchiffrer, est-ce exacte ?

Sinon voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <cstdlib>
#include <iostream>
#include <fstream>
 
using namespace std;
 
void crypt(const char *text, const char *key, char *crypted) {
     unsigned int j = 0;
     for (unsigned int i = 0; i<strlen(text); i++) {
         if (j >= strlen(key)) {
               j=0;
         }
         crypted[i] = text[i]^key[j];
         j++;
     }
}
 
int main(int argc, char *argv[])
{
    char *key = "9cdfb439c7876e703e307864c9167a15";
    fstream file_in("text.txt", ios::in|ios::binary);
    fstream file_out("text-out.txt", ios::out|ios::binary);
    int iter = 0;
    const int tranche = 192;
    char buffer[tranche];
    while (!file_in.eof()) {
          file_in.getline(buffer, (iter*tranche)+tranche);
          char tmp[tranche];
          crypt(buffer, key, tmp);
          strcpy(buffer, tmp);
          file_out.write(buffer, strlen(buffer));
          iter++;
    }
    file_in.close();
    file_out.close();
 
    cout << "\nFini\n";
    system("PAUSE");
    return 0;
}

Ce serait pour après mais peut-être aussi pouvez-vous m'aider pour que la clé key soit interpretée comme du hex car pour le moment c'est du char.
J'ai sûrement fait des erreurs bêtes et coder comme un pied mais j'espère que vous saurez me mettre sur le bon chemin !

Merci d'avance.

[amaury pouly]

Cette ligne pose problème:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
file_in.getline(buffer, (iter*tranche)+tranche);

Puisque "getline" attends comme second paramètre la taille du buffer, or ton buffer est de taille "tranche" et non pas de taille (iter*tranche)+tranche.

[jamesb]

Ah oui ça change tout, par contre j'ai toujours un gros problème avec les fichiers. Je n'obtient pas les mêmes fichiers à l'arrivée.

Voici le bout de code simplifié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
int main(int argc, char *argv[])
{
    char *key = "9cdfb439c7876e703e307864c9167a15";
    char *filename_in = "image-tocrypt.jpg";
    char *filename_out = "image-out.jpg";
    fstream file_in(filename_in, ios::in|ios::binary);
    fstream file_out(filename_out, ios::out|ios::binary);
 
    if (!file_in || !file_out) {
          cout << "Impossible d'ouvrir !";
          return 0;
    }
 
    int iter = 0;
    const int tranche = 192;
    char buffer[tranche];
 
    // Determine la longueur du fichier
    file_in.seekg(0, ios::end);
    int file_inlength = file_in.tellg();
    file_in.seekg(0, ios::beg);
 
    while (iter*tranche < file_inlength) {
          file_in.read(buffer, tranche);
          //char tmp[tranche];
          //crypt(buffer, key, tmp);
          //strcpy(buffer, tmp);
          file_out.write(buffer, tranche);
          iter++;
    }
    file_in.close();
    file_out.close();
 
    cout << "\nFini\n";
    system("PAUSE");
    return 0;
}

J'ai testé avec une photo et si j'utilise getline c'est illisible alors qu'avec read c'est presque parfait. J'arrive à voir la photo mais il y a quelques octets en trop, 124 pour être précis. Poids avant: 33'860 o ; après : 33'984 o. Sûrement une erreur dans la boucle mais laquelle ?

[amaury pouly]

Le problème c'est que getline s'utilise principalement avec des fichiers texte, or avec des fichiers binaire, cela n'a pas de sens. Je te conseille d'utiliser read au lieu de getline. Notamment, getline va ignorer tous les '\n' qui peuvent tout à fait apparaître aléatoirement dans un fichier binaire.

[jamesb]

En effet je viens de l'apprendre à mes dépends. Je viens de corriger la copie est conforme (les deux MD5 concordent).

Maintenant il y a un problème avec le chiffrage. En effet j'ai remarqué que tout à l'air juste, j'ai vérifié par-ci par là c'est juste sauf le dernier byte où le xor semble être faux.

J'ai essayé de faire le déchiffrage mais c'est totalement faux, je retrouve à peine 50% des données. J'ai regardé en HEX et je voyais à peu près la moitié qui revenait par rapport au fichier original.

Je suis persuadé que vous pouvez m'aider, voici mon code actuellement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <cstdlib>
#include <iostream>
#include <fstream>
 
using namespace std;
 
void crypt(const char *text, const int length, const char *key, char *crypted) {
     int j = 0;
     for (int i = 0; i<length; i++) {
         if (j >= (signed) strlen(key)) {
               j=0;
         }
         crypted[i] = text[i]^key[j];
         j++;
     }
}
 
int main(int argc, char *argv[])
{
    char *key = "9cdfb439c7876e703e307864c9167a15";
    char *filename_in = "image-tocrypt.jpg";
    char *filename_out = "image-out.jpg";
    fstream file_in(filename_in, ios::in|ios::binary);
    fstream file_out(filename_out, ios::out|ios::binary);
 
    if (!file_in || !file_out) {
          cout << "Impossible d'ouvrir !";
          return 0;
    }
 
    int iter = 0;
    const int tranche = 192;
    char buffer[tranche];
 
    // Determine la longueur du fichier
    file_in.seekg(0, ios::end);
    int file_inlength = file_in.tellg();
    file_in.seekg(0, ios::beg);
 
    while (iter*tranche < file_inlength) {
          int readByte;
          readByte = tranche;
          if (iter*tranche+tranche > file_inlength)
             readByte = file_inlength-iter*tranche;
          strcpy(buffer, "");
          file_in.read(buffer, readByte);
          char tmp[tranche];
          crypt(buffer, readByte, key, tmp);
          strcpy(buffer, tmp);
          file_out.write(buffer, readByte);
          iter++;
    }
    file_in.close();
    file_out.close();
 
    cout << "\nFini\n";
    system("PAUSE");
    return 0;
}

Merci d'avance !

PS: Apparement le chiffrage est faux, une partie des données est chiffrée mais pas tout. J'ai fais passé un fichier texte et on voit clairement des données, y'a quelque chose qui cloche ! (Normal du coup que le déchiffrage ne fonctionne pas).

[10_GOTO_10]

J'espère que ce que tu as à chiffrer n'est pas important. Le cryptage avec un XOR utilisé plus d'une fois, c'est à peu près équivalent à donner le fichier en clair (alors que, paradoxalement, utilisé une seule fois, il est prouvé que c'est absolument indéchiffrable ...).