Discussion :

[lionceau]

Bonjour j'ai un fichier que je veux hash , il compile et fonctionne , j'ai bien un hash mais il se termine avec une erreur compréhensible , avez vous svp une idée ?

l'erreur :
Run-Time Check Failure #2 - Stack around the variable 'mdString' was corrupted.

le .h

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
#ifndef HASHFILE_H
#define HASHFILE_H
 
#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <openssl/sha.h>
#include <iostream>
#include <fstream>
#include <sstream>
 
#ifndef SIZE_STRING
#define SIZE_STRING 20
#endif
 
namespace ToolLib {\

/////////////////////////////////////////////////////////////////////////////////////////
//! Manages a HashFile.
/////////////////////////////////////////////////////////////////////////////////////////
class HashFile
{
public:
   HashFile();
 	HashFile(std::string nameFile, std::string nameHash);
   virtual ~HashFile();
 
   char* generateHash(char* path);
   char* generateHash(std::ifstream myFile);
   char* generateHash();
//   bool checkHash(std::ifstream myFile, char* myHash);
   bool checkHash(std::string myFile, std::string myHash);
 
   // Getter & Setter
   void setm_File(std::string file);
   std::string getm_File();
   void setm_FileHash(std::string fileHash);
   std::string getm_FileHash();
 
private:
	std::string m_File  ;      // name of the file to do the integrity 
	std::string m_FileHash  ;  // name of the file who contain the hash of m_file
}; 
}
#endif

la fonction qui lance l erreur

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
char* HashFile::generateHash() 
{
 
   if( NULL != m_File.c_str() )
   {
      std::ofstream fileHash( m_FileHash.c_str(), ofstream::out|ofstream::trunc );
      std::ifstream file( m_File.c_str() );
      unsigned char digest[SHA512_DIGEST_LENGTH];
      char mdString[(SHA512_DIGEST_LENGTH * 2)+1 ];
      std::stringstream buffer; // variable qui contient tout le fichier
 
		if( file.is_open() && fileHash.is_open() )
		{			
			buffer << file.rdbuf();
			SHA512_CTX ctx;
			SHA512_Init( &ctx );
			SHA512_Update( &ctx, buffer.str().c_str(), strlen(buffer.str().c_str()) );
			SHA512_Final(digest, &ctx);
 
			for(int i = 0; i < SHA512_DIGEST_LENGTH; i++)
			{
            sprintf_s(&mdString[i*2],sizeof(&mdString[i*2]), "%02x", (unsigned int)digest[i]);
			}
        // mdString="ed f  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxaaaaaaaaaaaaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
 
			fileHash << mdString;
			printf_s("---SHA512 digest de \"%s\" : %s\n", m_File.c_str(), mdString);
		}
 
      if( file.is_open() )
		{
			file.close();
		}
 
		if( fileHash.is_open() )
		{
			fileHash.close();
		}
 
		//system("pause"); //[test]
		//effacement du contenu des variables
		//strcpy_s( mdString, sizeof(mdString), "" );
		buffer.clear();
 
      printf_s("-SHA512 digest de \"%s\" : %s\n", m_File.c_str(), mdString);
      return mdString;
	}
	else
	{
		printf_s( "\n\n Merci de mettre comme argument un fichier\n\n" );
      return 0;
	}
}

le main

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
 
#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <openssl/sha.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include "HashFile.h"
 
using namespace std;
 
 
int main(int argc, char * argv[])
{
 
   ToolLib::HashFile * ClassHashFile = new ToolLib::HashFile("test6.txt", "sha512test.txt");
   ClassHashFile->setm_File("test6.txt");
   ClassHashFile->setm_FileHash("sha512test.txt");
   printf_s("Le SHA512 digest de \"%s\" : %s\n", ClassHashFile->getm_File(), ClassHashFile->generateHash());
   delete ClassHashFile;
 
 
   return 0;
}

Merci pour vos conseils et aides.


l

[dalfab]

Bonjour,

Avant d'avoir un plantage à l'exécution, le compilateur t'a certainement indiqué des "warnings" à la compilation. Il faut les lire et les corriger.
L'erreur à l'exécution t'indique qu'à un moment tu as écris dans une zone où tu n'aurais dû. Une écriture dans un buffer a dû déborder.
En C++, on évite les pointeurs "nus" car ils sont sources de problèmes de corruption mémoire, c'est ce qui se passe ici.

[lionceau]

Bonjour , Merci pour ta réponse , qu'est ce que tu entends par les pointeurs nuls ?
Tu veux dire que je fasse ceci pour initialiser mdString ?

Code :

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

char mdString = malloc([(SHA512_DIGEST_LENGTH * 2)+1 ]*sizeof(char ));

[dalfab]

qu'est ce que tu entends par les pointeurs nuls ?
Tu veux dire que je fasse ceci pour initialiser mdString ?
char mdString = malloc([(SHA512_DIGEST_LENGTH * 2)+1 ]*sizeof(char ));

malloc() c'est du C, il n'existe aucune raison de l'utiliser en C++.

La fonction generateHash() retourne un char*; C'est là le problème. Ce qu'elle retourne doit pointer quelque part. Ou bien ce quelque part existe avant la fonction et on le pointe, ou bien il doit être alloué dynamiquement par new[] (surtout pas avec malloc()). Et dans ce dernier cas se poserait le problème de qui est responsable de la libération par delete[].
Ton code retourne un pointeur sur mdString[], donc un quelque part détruit à la sortie de la fonction, pas bon du tout. Seconde possibilité, ton malloc(), un peu mieux. Troisième possibilité, faire un new[], c'est du C++ mais il y a risque d'oubli de libérer. Quatrième possibilité, ne pas retourner un simple pointeur char*.
La mdString, comme son nom l'indique, est une chaîne de caractères. Il faut que la fonction generateHash() retourne une std::string, et donc :

Code :

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

1
2
3
4
5
6
7
8
9
  std::string mdString(SHA512_DIGEST_LENGTH*2,' ');
  char* bufInStr = const_cast<char*>(mdString.data()); // on peut ecrire dans une string 
  for ( int i = 0 ; i < SHA512_DIGEST_LENGTH ; i++ ) {
      // mais le caractere \0 ne doit jamais etre mis dans une std::string
      // on ne peut donc pas utiliser la fonction C sprintf_s()
      bufInStr[i*2] = "0123456789abcdef"[15 & (digest[i]>>4)];
      bufInStr[i*2+1] = "0123456789abcdef"[15 & digest[i]];
  }
  return mdString;

[Médinoc]

Tu devrais peut-être utiliser &mdString[0] plutôt qu'un const_cast.
(et en C++98, j'utiliserais plutôt un vecteur de char que je convertirais en string à la fin).
Edit: En fait, dans le cas présent je ne vois même pas pourquoi j'utiliserais un pointeur plutôt qu'accéder directement aux caractères via l'opérateur crochet; normalement ça devrait être inliné au point de se comporter comme le pointeur...

PS: Ceci est du C++ normal, pas du C++/CLI.

[lionceau]

Bonjour,

dalfab > J'ai testé , ca fonctionne , merci .
J'ai une question :
A quoi correspond ?

Code :

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

bufInStr[i*2] = "0123456789abcdef"[15 & (digest[i]>>4)];

[dalfab]

J'y suis allé un peu fort dans l'opacité sur cette ligne, si je l'écris en plusieurs, cela devient

Code :

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

1
2
3
4
5
6
const char tabCaractHexa[] = "0123456789abcdef";
int valeurAConvertir = digest[i];
int premier = (valeurAConvertir >> 4) & 0xF; // partie 'haute' de l'octet
int second  = valeurAConvertir & 0xF;        // partie basse -> unité en base 16
bufInStr[i*2]   = tabCaractHexa[premier];    // conversion 0 à 15 en '0' à 'F'
bufInStr[i*2+1] = tabCaractHexa[second];     // conversion 0 à 15 en '0' à 'F'

Il doit y avoir plus simple

[lionceau]

Bonjour Dalfab,

Merci pour l'explication. La fonction fonctionne bien pour des fichiers de 1go mais pas avec les fichiers de 10go à 30go et plus, as tu une idée de comment faire ceci ?
c 'est le iftream qui deconne .

[Médinoc]

Si j'ai bien compris, c'est parce que ton code met tout le fichier dans une variable. Il faut faire la lecture et le hachage par blocs.

[bacelar]

Merci pour l'explication. La fonction fonctionne bien pour des fichiers de 1go mais pas avec les fichiers de 10go à 30go et plus, as tu une idée de comment faire ceci ?

Même en compilant en 64bit ?

[lionceau]

Mais le soucis est que je peux pas lire le fichier morceau par morceau pour après faire un hash d'une variable qui est entière .

[lionceau]

Non il y avait pas de soucis , en fait j'ai essayé de faire un hash d'un dump de mémoire ou faire un hash de fichier créer à l'aide de

Code :

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

fsutil.exe file createnew %UserProfile%\Desktop\70G 70000000000

, mais ces fichiers sont corrompu. Donc impossible de hasher un fichier corrompu. Normal ..

Donc tout fonctionne bien

Merci à tous pour vos soutiens et conseils

Sujet résolu.


Bonne soirée ,

[lionceau]

Le soucis est que cette fonction hash bien les fichiers .txt mais pas les archives .7z et .zip.

Je pense fortement que le soucis provient de cette ligne pour ouvrir un fichier Zip :

Code :

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

std::ifstream file( m_File.c_str() );

Est ce que vous me conseillez d'utiliser une autre fonction\type que ifstream ?

Le soucis est que je suis obligé d'utiliser un ifstream car je travaille avec des petits et des gros fichiers (30 giga max) et le second soucis est que ifstream n'aime pas les zip et 7z

Svp , quel type me conseillez vous pour charger un zip ou un fichier video de 30giga maximum ?

Merci

[Médinoc]

Comme je te dis, fais ton hachage par blocs (je tends à utiliser des blocs de 1MO, personnellement).
Si tu ne fais l'appel à SHA512_Final() qu'après avoir traité le dernier bloc (et que tu ne fais le Init() qu'avant de traiter le premier)...

Edit: Sous Visual Studio, j'ai déjà utilisé ce code par le passé. Il peut calculer plusieurs hashes en même temps pour le même fichier, par blocs de 1Mo.

Code C :

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
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
#ifndef _WIN32_WINNT		// Allow use of features specific to Windows XP or later.                   
#define _WIN32_WINNT 0x0501	// Change this to the appropriate value to target other versions of Windows.
#endif						
 
#include <stdio.h>
#include <tchar.h>
#include <windows.h>
 
#define BUFFER_SIZE (1<<20)
 
ALG_ID hashIds[] = { CALG_MD5, CALG_SHA1/*, CALG_SHA_256*/ };
char const * hashNames[] = { "MD5    ", "SHA-1  ", "SHA-256" };
 
 
static BOOL DisplayHashValue(HCRYPTHASH hHash, LPCSTR name)
{
	BOOL ret = FALSE;
	DWORD cb = 0;
	DWORD len = sizeof cb;
	BOOL bCb = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&cb, &len, 0);
	if(bCb)
	{
		BYTE * hashVal = malloc(cb);
		len = cb;
		if(hashVal)
		{
			BOOL bVal = CryptGetHashParam(hHash, HP_HASHVAL, hashVal, &len, 0);
			if(bVal)
			{
				size_t i;
				printf("%s : ", name);
				for(i=0 ; i<len ; i++)
				{
					printf("%02x", hashVal[i]);
				}
				putchar('\n');
				ret = TRUE;
			}
 
			free(hashVal);
		}
	}
	return ret;
}
 
static BOOL HashOneFile(LPCTSTR fileName, HCRYPTPROV hProv, LPVOID buf, DWORD size)
{
	BOOL ret = FALSE;
	HCRYPTHASH hHash[ARRAYSIZE(hashIds)] = {0};
	BOOL bHashes = TRUE;
	size_t iHash;
	for(iHash=0 ; iHash < ARRAYSIZE(hashIds) && bHashes; iHash++)
		bHashes = bHashes && CryptCreateHash(hProv, hashIds[iHash], 0, 0, &hHash[iHash]);
	if(bHashes)
	{
		HANDLE hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
		if(hFile != INVALID_HANDLE_VALUE)
		{
			DWORD dwRead = 0;
			BOOL bRead = FALSE;
			bHashes = TRUE;
			do
			{
				bRead = ReadFile(hFile, buf, size, &dwRead, NULL);
				if(!bRead)
					break;
				for(iHash=0 ; iHash < ARRAYSIZE(hashIds) && bHashes; iHash++)
					bHashes &= CryptHashData(hHash[iHash], buf, dwRead, 0);
 
			} while(bRead && dwRead != 0 && bHashes);
			if(bRead && bHashes)
			{
				ret = TRUE;
				for(iHash=0 ; iHash < ARRAYSIZE(hashIds) ; iHash++)
					ret &= DisplayHashValue(hHash[iHash], hashNames[iHash]);
			}
 
			CloseHandle(hFile);
		}
 
		for(iHash=0 ; iHash < ARRAYSIZE(hashIds) ; iHash++)
			CryptDestroyHash(hHash[iHash]);
	}
	else
	{
		size_t nHashes = iHash;
		for(iHash=0 ; iHash < nHashes ; iHash++)
			CryptDestroyHash(hHash[iHash]);
	}
	return ret;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
	int ret = EXIT_FAILURE;
	HCRYPTPROV hProv = 0;
	BOOL bProv = FALSE;
	if(argc<2)
	{
		puts("Usage: HashFile <filename>");
		return 1;
	}
 
	bProv = CryptAcquireContext(&hProv, NULL, NULL, PROV_DSS/*PROV_RSA_FULL*/, CRYPT_VERIFYCONTEXT);
	if(!bProv)
	{
		fprintf(stderr, "CryptAcquireContext() failed with error %lu.\n", GetLastError());
	}
	else
	{
		LPVOID buf = VirtualAlloc(NULL, BUFFER_SIZE, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
		if(buf==NULL)
		{
			fprintf(stderr, "VirtualAlloc() failed with error %lu.\n", GetLastError());
		}
		else
		{
			if(HashOneFile(argv[1], hProv, buf, BUFFER_SIZE))
				ret = EXIT_SUCCESS;
			else
				fprintf(stderr, "HashOneFile() failed (last Win32 error: %lu).\n", GetLastError());
 
			VirtualFree(buf, 0, MEM_RELEASE);
		}
		CryptReleaseContext(hProv, 0);
	}
	if(ret != EXIT_SUCCESS)
		fprintf(stderr, "Failed.\n");
	return ret;
}

[lionceau]

Merci pour ta réponse mais j'ai du mal à comprendre ce que tu veux dire. ( car je fais bien le SHA512_Init(); puis le SHA512_Final() ? En quoi la taille du bloc va changer quelque chose ?)

Je pensais plus pouvoir régler le soucis en touchant à cette ligne std::ifstream file( m_NameFile.c_str() );Par exemple en la remplacant avec std::ifstream file( m_NameFile.c_str() ,std::ifstream::in|std::ifstream||binary); mais cela ne change rien.

Merci pour tes conseils

Ci dessous 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
41
42
43
44
45
46
47
48
49
50
bool bHashDone = false;
	std::ofstream fileHash;
	std::ifstream file;
 
   if( NULL != m_NameFile.c_str() )
   {
      try
      {
		  SystemConfiguration::COutilsCommun::OpenOStream(fileHash,m_NameFileHash.c_str());
		  SystemConfiguration::COutilsCommun::OpenIStream(file, m_NameFile.c_str());
 
		  std::ofstream fileHash( m_NameFileHash.c_str(), std::ofstream::out|std::ofstream::trunc );
         std::ifstream file( m_NameFile.c_str() );
         // if std::ifstream file is huge ( I have one error then I must read the 
         if(!file)
         {
			 std::cout << "impossible d'ourvrir le fichier : " << m_NameFile.c_str() <<std::endl;
			 std::cout << "taille du fichier : " << file.tellg() <<std::endl;
         }      
		 if(!fileHash)
		 {
			 std::cout << "impossible de creer le fichier : " << m_NameFileHash.c_str() <<std::endl;
		 }   
 
         unsigned char digest[SHA512_DIGEST_LENGTH];
         std::string mdString(SHA512_DIGEST_LENGTH*2,' ');
         std::stringstream buffer; //// variable with the content of the file 
 
         if( (file)&& (fileHash) )
         {			
            buffer << file.rdbuf();
            SHA512_CTX ctx;
            SHA512_Init( &ctx );
            SHA512_Update( &ctx, buffer.str().c_str(), strlen(buffer.str().c_str()) );
            SHA512_Final(digest, &ctx);
 
            char* bufInStr = const_cast<char*>(mdString.data()); 
            for ( int i = 0 ; i < SHA512_DIGEST_LENGTH ; ++i ) {
               // FYI : don't use sprintf_s() because  \0 can't be inside std::string
               const char tabCaractHexa[] = "0123456789abcdef";
               int valueToConvert = digest[i];
               int first = (valueToConvert >> 4) & 0xF; 
               int second  = valueToConvert & 0xF;      
               bufInStr[i*2]   = tabCaractHexa[first];  
               bufInStr[i*2+1] = tabCaractHexa[second];
            }
			bHashDone = true;
            fileHash << mdString;
            std::cout <<"SHA512 digest of  " << m_NameFile.c_str() << " is "<< mdString <<  std::endl;
         }

[Médinoc]

Tu persistes à charger et traiter tout le contenu du fichier d'un seul coup.

Et en plus, tu devrais mettre l'affichage du contenu du hash dans une fonction séparée, mais bon on n'est pas à ça près.

[lionceau]

Si j'ai bien compris , concrètement il faudrait que je fasse ceci en plusieurs étapes ?

Code :

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

SHA512_Update( &ctx, buffer.str().c_str(), strlen(buffer.str().c_str()) );

[Médinoc]

Ça et la lecture du fichier.

[lionceau]

Code :

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

1
2
3
buffer << file.rdbuf();
 
SHA512_Update( &ctx, buffer.str().c_str(), strlen(buffer.str().c_str()) );

Donc je dois faire ces deux lignes en plusieurs étapes , mais je ne comprend pas trois choses :
1 Pourquoi est ce qu'il faut faire ceci en plusieurs étapes ?
2 En combien d'étape je dois faire ceci ?
3 Comment faire ceci ? Je trouve pas de source/exemple sur internet pour travailler avec un buffer morceau par morceau

[lionceau]

Je me suis basé sur ce lien pour ne plus faire le

Code :

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

buffer << file.rdbuf();

https://stackoverflow.com/questions/...-istringstream

Ca compile et ca s’exécute bien mais le hash ne fonctionne pas, je n'ai pas l'impression d'etre dans la bonne direction .
Je suis perdu pour reussir comment gerer un fichier en C

Stp qu'est ce que je peux changer avec

Code :

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

SHA512_Update( &ctx, buffer.str().c_str(), strlen(buffer.str().c_str()) );

???