Discussion :

[Argol_Medusa]

Bonjour à tous,

je suis en train de coder une partie de classe permettant de crypter/décrypter des données de manière très basique avec un simple XOR.

Pour se faire je test sur un simple fichier pour commencer ( et non directement sur des frames réseau via liaison TCP/IP ).

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
void C_PWI_Engine::Decrypter(AnsiString Nom_Fichier)
{
	FILE *Fich;

	Fich = fopen(Nom_Fichier.c_str(),"r+b");
	unsigned long int SizeOfBuffer = 4096;
	unsigned __int64 *Int64_Buff;
	unsigned __int64 Int64_Clef=0x1122334455667788;
	char *Buffer;
	Buffer = new char[SizeOfBuffer];

	for (unsigned long int i = 0; i < Filesize(Fich); i += SizeOfBuffer)
	{
		fseek(Fich,i,SEEK_SET);
		fread(Buffer,SizeOfBuffer,1,Fich);

		/* Crypte ou decrypte ( involutif ) */

		for (unsigned long int j = 0; j < SizeOfBuffer; j++)
		{
			Int64_Buff = (unsigned __int64*) ((void) (Buffer+j));
			*Int64_Buff = *Int64_Buff ^ Int64_Clef;
		}

		/* ecrit vers fichier destination */
		fseek(Fich,i,SEEK_SET);
		fwrite(Buffer,SizeOfBuffer,1,Fich);
	}
	fclose(Fich);
	delete Buffer;
}

Problème : c'est lent.

Du coup je me suis dit qu'en déclarant un __int64 je devrais théoriquement pouvoir utiliser toute la puissance du processeur 64bits et de son opérateur XOR ( qui doit être si mes souvenirs sont bons plus rapide qu'un ADD ou toute autre opération ).

sauf que j'ai un soushi avec la ligne en rouge.
Comment peut-on faire pointer un __int64 sur un tableau d'octets (de char) ?
Je sais que c'est possible car je l'ai déjà fait par le passé mais je ne me rappelle plus de la syntaxe exacte ( reinterpret_cast ? )


Seconde question : l'utilisation d'un __int64 est-elle un plus ou le compilateur va-t-il de toute façon reconvertir derrière (cas d'une machine 32bits) ??

Merci d'avance pour vos réponses et vos conseils sur l'algorithme que vous utiliseriez pour avoir une vitesse maximale !

[totoche76]

Hello,

Pour ton problème de cast, tu es à une étoile près:

Code :

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

	Int64_Buff = (unsigned __int64*) ((void*) (Buffer+j));

Sinon, le void (étoile ou pas) ne sert à rien, ceci a l'air de marcher aussi:

Code :

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

	Int64_Buff = reinterpret_cast<unsigned __int64*>(Buffer+j);

[Argol_Medusa]

Arf ... merci beaucoup, décidément j'ai besoin de vacances moi

Effectivement je viens de tester ça marche je me retrouve bien avec le pointeur __int64 à l'adresse de mon tableau de char.

Concernant l'algo optimisée ( ou pas ) avec les __int64, si quelqu'un a des infos je suis tout de même preneur.

[ShaiLeTroll]

Question, en ne faisant pas de calcul, juste en mettant ceci

Code :

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

1
2
3
4
5
 
                fseek(Fich,i,SEEK_SET);
		fread(Buffer,SizeOfBuffer,1,Fich);
		fseek(Fich,i,SEEK_SET);
		fwrite(Buffer,SizeOfBuffer,1,Fich);

Quel est la différence de temps avec le XOR ?
Tu auras le temps réelle de cette opération !
Car la tu lis et écris dans le même fichier, le Seek n'est-il pas une opération un peu lente ?
Ecrire dans un fichier temporaire serait plus rapide à mon avis !

sinon ta boucle, je modifierais le pas, cela suffit !

Code :

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

1
2
3
4
5
6
 
                for (unsigned long int j = 0; j < SizeOfBuffer; j += sizeof(__int64))
		{
			Int64_Buff = (unsigned __int64*)(Buffer + j);
			*Int64_Buff = *Int64_Buff ^ Int64_Clef;
		}

ou par tableau

Code :

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

1
2
3
4
5
6
 
                for (unsigned long int j = 0; j < SizeOfBuffer / sizeof(__int64); j++)
		{
			Int64_Buff = &((unsigned __int64*)Buffer)[j];
			*Int64_Buff = *Int64_Buff ^ Int64_Clef;
		}

tient un petit comparatif

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
{
  char *Buffer = new char[6];
  *((short*)Buffer) = 33833; // 1000 0100 0010 1001 // 8429 -> „) -> LE : )„
  *((short*)(Buffer + sizeof(short))) = 37446; // 1001 0010 0100 0110 // 9246 -> ’F -> LE : F’
  *((short*)(Buffer + 2 * (sizeof(short)))) = 101; // 0000 0000 0110 0101 // 0065 -> zero e -> LE : e zero
  ShowMessage(Buffer); // )„F’e
  delete [] Buffer;
 
  Buffer = new char[6];
  ((short*)Buffer)[0] = 33833; // 1000 0100 0010 1001 // 8429 -> „) -> LE : )„
  ((short*)Buffer)[1] = 37446; // 1001 0010 0100 0110 // 9246 -> ’F -> LE : F’
  ((short*)Buffer)[2] = 101; // 0000 0000 0110 0101 // 0065 -> zero e -> LE : e zero
  ShowMessage(Buffer); // )„F’e
  delete [] Buffer;
}

Sinon change la forme du buffer

Code :

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

__int64* Buffer = new __int64[SizeOfBuffer / sizeof(__int64)];

Cela sera plus facile à parcourir !

Code :

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

1
2
3
 
                for (unsigned long int j = 0; j < SizeOfBuffer / sizeof(__int64); j++)
			Buffer[j] ^= Int64_Clef;

Faudra penser à la phase finale, si tu ne lit que 1 à 7 octet dans le fichier et non 8 !




Tu aurais faire ton code sur un TStream ainsi il aurait été compatible avec un TFileStream, un TMemoryStream utilisé dans le cas du TCP\IP

Pour les performances, utilise NativeUInt, un type de XE2, il sera en 32 ou 64bits selon l'architecture, avec sizeof tu pourras gérer sa longueur facilement !

Enfin attention ton Delete ! new[] -> delete[] !

[Argol_Medusa]

Merci pour ton aide Shai.

Alors oui je mesure effectivement le temps total, donc fseek/fread + "XORage"

je vais mettre des gettick pour séparer un peu ces temps et pouvoir analyser le temps uniquement du au xor.

Le NativeUInt j'ai jamais essayé, je vais voir ce que ça donne et utiliser une TStream aussi peut-etre tant qu'à faire.

(Joli oublie de delete sinon en effet )

[Argol_Medusa]

J'ai avancé un peu, pas encore testé en stream je reste sur le fichier pour l'instant.

En mettant le fichier complet (40Mo) en buffer, j'arrive à avaler les 40 Mo en moins d'une seconde ... wow !

C'était donc bien l'accès disque qui était le plus long.

Par contre 2 questions concernant le sizeof(__int64) : il me retourne 4 alors que la taille du __int64 est 8 octets !

Du coup j'ai ajouté un 2* dans le code mais j'aimerais bien comprendre pourquoi ??

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
void C_PWI_Engine::Decrypter(AnsiString Nom_Fichier)
{
	clock_t start, end;
	start = clock();
 
	/* Definir la clef de cryptage 64 bits */
	unsigned __int64 Int64_Clef=CLEF_DE_CRYPTAGE;
 
	/* Ouvrir le fichier */
	FILE *Fich;
	Fich = fopen(Nom_Fichier.c_str(),"r+b");
	if (Fich != NULL)
	{
 
 
		/* Recuperer la taille du fichier */
		unsigned long int FileSize = Filesize(Fich);
 
		/* Creer un buffer pour stocker le fichier en memoire */
		unsigned __int64 *Int64_Buff;
		char *Buffer;
		Buffer = new char[FileSize+8]; // +8 histoire de ne pas risquer de buffer overflow
 
		/* Charger le programme en mémoire */
		fseek(Fich,0,SEEK_SET);
		fread(Buffer,FileSize,1,Fich);
 
		/* Crypter ou decrypter ( involutif ) */
		unsigned long int i=0;
		while(i<FileSize)
		{
			Int64_Buff  = (unsigned __int64*) (Buffer+i);
			*Int64_Buff ^= Int64_Clef;

Code :

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

	        	i += 2*sizeof(Int64_Buff);

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
 
		}
 
		/* enregistrer les modifications dans fichier destination */
		fseek(Fich,0,SEEK_SET);
		fwrite(Buffer,FileSize,1,Fich);
 
		/*  fermer le fichier et supprimer le buffer */
		fclose(Fich);
		delete Buffer;
		Buffer = NULL;
 
		end = clock();
		AnsiString txt= "temp écoulé = ";
		txt = txt + IntToStr( (__int64) ((end - start) / CLK_TCK) ); // sortie = 1s sur une brouette
		txt = txt + "s";
 
		ShowMessage(txt);
	}
}

Sinon concernant le type NativeUInt impossible à utiliser : je crois qu'avec le 2010 il n'est effectivement pas disponible, il va falloir que j'installe l'update XE2.

Ha oui et j'ai géré la fin de fichier en mettant un Buffer = new char[FileSize+8];
Les derniers octets à crypter seront donc possiblement des octets bidons mais ça évite d'avoir à gérer la fin de fichier.

[ShaiLeTroll]

je te garanti que sizeof(__int64) == 8, tu n'aurais pas fait un sizeof sur un __int64* et la oui, un pointer sous D2010 c'est toujours 4 !

EDIT :
Ah ben, si je viens de voir l'extrait de code unsigned __int64 *Int64_Buff;.

Evidemment sizeof(Int64_Buff) == 4 et sizeof(*Int64_Buff) == 8

[Argol_Medusa]

Bingo c'est ça !

Merci Shai !

[Argol_Medusa]

La fonction en version lecture de fichier fonctionnant très bien, je viens d'overloader ma fonction décrypter pour pouvoir utiliser une Stream comme conseillé.

Mais je me choppe une violation d'accès lors de l'exécution, pour i = 5Mo à peut pret.

Je n'arrive pas à voir où je me suis planté.
L'utilisation de Stream->Memory est-elle incorrecte ?

Ai-je le droit d'étendre la taille de ma stream avec "Stream->Size = FileSize+8;" ?
Au cas où ce n'est pas le cas je vais faire à la main les derniers octets (à terminer en fonction du nombre d'octet restant, mais ça plante avant dans la boucle ).

Si quelqu'un voit d'où l'erreur peut provenir, je suis preneur !

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
void C_Cryptage::Decrypter(TMemoryStream *Stream)
{
	/* Definir la clef de cryptage 64 bits */
	unsigned __int64 Int64_Clef=CLEF_DE_CRYPTAGE;

	if (Stream != NULL)
	{
		/*! Recuperer la taille de la stream */
		unsigned long int FileSize = Stream->Size;

		/* Agrandir un peu la stream pour ne pas risquer de dépassement */
		unsigned __int64 *Int64_Buff;
		Stream->Size = FileSize; //+8; // +8 histoire de ne pas risquer de buffer overflow


		/* Crypter ou decrypter ( involutif ) */
		static unsigned long int i=0;
		while(i<FileSize-8)
		{
			Int64_Buff  = i + (unsigned __int64*) (Stream->Memory);
			*Int64_Buff ^= Int64_Clef;
			i += sizeof(*Int64_Buff);
		}
		char *ptr;
		ptr = (char*) (i + (char*)(Stream->Memory));
		ptr[0] ^= (char) ((Int64_Clef) & 0xFF);
		ptr[1] ^= (char) ((Int64_Clef>>8) & 0xFF);
		ptr[2] ^= (char) ((Int64_Clef>>16) & 0xFF);
		ptr[3] ^= (char) ((Int64_Clef>>24) & 0xFF);
		ptr[4] ^= (char) ((Int64_Clef>>32) & 0xFF);
		ptr[5] ^= (char) ((Int64_Clef>>40) & 0xFF);
		ptr[6] ^= (char) ((Int64_Clef>>48) & 0xFF);
		ptr[7] ^= (char) ((Int64_Clef>>56) & 0xFF);
	}
}

[ShaiLeTroll]

Pourquoi ne pas utiliser la méthode Read \ Write au lieu de faire tous ces calculs de pointeurs ?

En plus, Read\Write indique le nombre d'octet réellement lu ou écrit dans le Stream !

TMemoryStream ???
D'où viennent les données

Tu m'expliques le but de

Code :

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

1
2
	unsigned long int FileSize = Stream->Size;
	Stream->Size = FileSize; // + 8

Si Size est égale à zéro, le mémoire pointe sur NULL à mon avis !

Voici une version TStream qui fonctionnera sur TFileStream, TMemoryStream ou encore TStringStream ...

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
 
void C_Cryptage::Decrypter(TStream *Src, TStream *Dest)
{
	/* Definir la clef de cryptage 64 bits */
	unsigned __int64 Int64_Clef=CLEF_DE_CRYPTAGE;
        unsigned __int64 *Int64_Buff;
 
	if (Src && Dest && (Src != Dest))
	{
		Dest->Size = Dest->Position + Scr->Size; // Fonctionnement différent selon implémentation
 
		while(Scr->Position < Scr->Size)
		{
		  int readcount = Scr->Read(Int64_Buff, sizeof(*Int64_Buff));
                  *Int64_Buff ^= Int64_Clef; // little endian mais c'est pas grave un xor n'est pas affecté normalement par cela !
                  Dest->Write(Int64_Buff, readcount); // écrit le nombre d'octet lu même si le calcul XOR a été effectué sur 8 octets
		}		
	}
}

A noter que ce code sur un TFileStream pourra être un peu lent, utiliser un TBufferedFileStream codé à la main
donc une optimisation possible

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
 
void C_Cryptage::Decrypter(TStream *Src, TStream *Dest)
{
	/* Definir la clef de cryptage 64 bits */
	unsigned __int64 Int64_Clef=CLEF_DE_CRYPTAGE;
        unsigned __int64 Int64_Buff[4096];
 
	if (Src && Dest && (Src != Dest))
	{
		Dest->Size = Dest->Position + Scr->Size; // Fonctionnement différent selon implémentation
 
		while(Scr->Position < Scr->Size)
		{
                  int readcount = Scr->Read(Int64_Buff, sizeof(Int64_Buff)); // lecture 32Ko ou un packet partiel
 
                  bufcount = readcount / 8 + (readcount % 8 ? 1 : 0);
                  for (int i = 0; i < bufcount; i++)
                    Int64_Buff[i] ^= Int64_Clef; 
 
 
                  Dest->Write(Int64_Buff, readcount); // Ecrit 32Ko tout en gérant un packet partiel
		}		
	}
}

Si tu veux forcément travailler sur un Buffer mémoire, revient à un XOR sur un octet !
As-tu vérifier si le temps de 8 XOR 8bits était vraiment plus lent qu'un XOR 64Bits ?
Tu es au départ parti sur du fichier et maintenant, tu traite de la mémoire, les temps ne seront pas les mêmes !

Ton code était lent à cause de la série fseek\fread\fseek\fwrite sur le même fichier, tu n'as pas remis en cause ce système de XOR 64bits !

[Argol_Medusa]

Je n'ai pas utilisé volontairement de read / write car je pensais que ça irait plus vite avec des pointeurs.
Ceci dit, je n'ai pas encore placé de commandes pour mesurer les temps, donc peut-être que je me trompe, je suis impatient d'ailleurs de tester les 2 solutions.
Sinon c'est sur que je ne m'amuserais pas à ça si je n'avais pas de contraintes niveau temps de calcul.


Les données peuvent provenir de plusieurs endroits différents ( internet, fichiers, tampon mémoire passerelle entre 2 applications.
Je ne suis pas habitué à utiliser d'autres types de streams que les memorystream en fait, je vais aller me lire la doc histoire de comprendre un peu mieux le fonctionnement de cette grande famille de stream.

Le but de

Code :

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

1
2
	unsigned long int FileSize = Stream->Size;
	Stream->Size = FileSize + 8;

est d'agrandir la stream pour être certain qu'on ne déborde pas lors de la dernière commande de XOR sur 64 bits ( suivant où le fichier se termine ).
J'ai fais comme ça sur la version en buffer de char classique, mais en version stream je n'ai pas encore trouvé comment rajouter 8 octets de plus en taille, j'ai donc procédé comme ça mais je ne suis pas sur que ça fonctionne vraiment ( je vais regarder la doc ).

Pour le size=0 ce ne sera pas le cas en pratique, j'assure en amont qu'on ai bien au moins quelques octets à crypter.
Ceci dit le cas où ça arrive n'ai pas encore traité avec le else, il le sera quand même par précaution.


Je vais tester ton exemple aujourd'hui, merci Shaï !