Discussion :

[Alast0rs]

EDIT :

Bon j'ai réétudier la question, construit un code plus léger etc..
Mais le problème est toujours le même ..

J'écris un module de chiffrage utilisant l'algorithme de rijndael, celui ci nécessite des bloc de 16 octet qu'il chiffre.

Hors admettons que mon fichier pèse 205 octets ... il y a donc 12 bloc de 16 octets qui seront chiffré mais la ou il y a erreur .. c'est sur les derniers octets :
12 * 16 = 192 octets
205 - 192 = 13 octets ...

Donc lors du dernier passage, on envoie 13 octets normaux et 3 octets X ... ce qui fausse le fichier crypté.

Exemple :

Ceci est le texte a chiffrer.
En plus, normalement, il ne contient aucune fautes.
Mais surtout, bien écrit.

Deviens :

Ceci est le texte a chiffrer.
En plus, normalement, il ne contient aucune fautes.
Mais surtout, bien écrit.

Je remplace les espaces par des % :

Ceci%est%le%texte%a%chiffrer.
En%plus,%normalement,%il%ne%contient%aucune%fautes.
Mais%surtout,%bien%écrit.%%%

Donc le fichier de base et le fichier décrypté ne sont plus identique.
Existe t-il une solution simple a cela ?

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
 
void FileModule::CryptFile(std::string filepath, std::string key)
{
    std::ifstream inFile(filepath.c_str(), std::ios::binary);
    std::ofstream outFile("CryptTest.txt", std::ios::binary);
 
    inFile.seekg( 0 , std::ios_base::end );
    long sizeFile = inFile.tellg() ;
    inFile.seekg( 0,  std::ios_base::beg ) ;
 
    int cycle = ( sizeFile / 16 );
    int lastoctect = ( sizeFile % 16 );
 
    unsigned char ukey[] = "aaaaaaaabbbbbbbb";
 
    /*while ( !inFile.eof() )
    {
        unsigned char buffer[16];
 
        inFile.read((char*)buffer, sizeof(buffer));
 
        pAESMod->RijndaelCrypt(buffer, ukey, 0);
 
        outFile.write((const char*)buffer, sizeof(buffer));
    }*/
 
    for ( int i = 0; i < cycle ; i++ )
    {
        unsigned char buffer[16];
 
        inFile.read((char*)buffer, sizeof(buffer));
 
        pAESMod->RijndaelCrypt(buffer, ukey, 0);
 
        outFile.write((const char*)buffer, sizeof(buffer));
    }
 
    if ( lastoctect != 0 )
    {
        unsigned char mbuffer[lastoctect];
 
        inFile.read((char*)mbuffer, sizeof(mbuffer));
 
        unsigned char buffer[16] = "";
 
        for ( size_t i = 0; i < sizeof(mbuffer); i++ )
        {
            buffer[i] = mbuffer[i];
        }
 
        pAESMod->RijndaelCrypt(buffer, ukey, 0);
 
        outFile.write((const char*)buffer, sizeof(buffer));
    }
 
    outFile.close();
    inFile.close();
};

PS : le code entre /* */ pourrait être une alternative .. qui ne fonctionne pas .. rajoute plus de caractère et fausse d'autant plus le résultat.

[cycloop]

Je pense que si ton algo nécessite des bloc de 16 char, il faut lui envoyer 16 char...

A partir de là, voilà la solution que j'imagine :
Il faut établir une convention pour les octets de remplissage. Ensuite, il faut faire un traitement au moment du décodage pour supprimer ces octets à la fin.

[ram-0000]

AES-128 traite des blocs de 16 octets. Si tes blocs ne font pas 16 octets (le dernier bloc surtout), ce n'est pas le problème d'AES mais c'est une convention à établir entre l'émetteur et le récepteur.

Ici, plusieurs stratégies de padding avec pour chacune, leurs avantages, leurs inconvénients et leur applicabilité (suivant le message transporté) : http://www.di-mgt.com.au/cryptopad.html

[Alast0rs]

Merci beaucoup pour ces informations