Durch einen Pufferüberlauf in PCFix.exe wurde der interne Programmzustand beschädigt. Klicken Sie auf "Unterbrechen", um das Programm zu debuggen, oder auf "Weiter", um es zu beenden.

Weitere Informationen finden Sie im Hilfethema "Gewusst wie: Debugging von Pufferüberlaufproblemen".

Hier der Code:

aus sicherheitsgründen entfernt

Wenn ich beide Teile laufen lasse bekomme ich den Fehler. Sobald ich ein Teil auskommentiere geht das Programm ohne Fehlermeldung durch.
Hoffe jemand sieht wo der Fehler ist, denn ich starre schon seit 2 Tagen auf den Code, kann den Fehler aber leide nicht ausmachen.

Mit freundlich Grüßen
pc-jedi

Allerdings kann ich das ohne den betreffenden Code nicht mit Sicherheit sagen; meine Kristallkugel ist in Reparatur.

ich habe Letzteres im Verdacht; der C-Format-String lässt mich vermuten, dass die Parameter schlussendlich in eine *printf-Funktion geschmissen wird, und std::string lässt sich nicht in %s quetschen.

Allerdings kann ich das ohne den betreffenden Code nicht mit Sicherheit sagen; meine Kristallkugel ist in Reparatur.

g_pLogfile->fTextout erwartet einen char und schreibt diesen dann in die Logfile.txt

void CLogfile::Textout (const char *Text)
{
	// Text schreiben und flushen
	fprintf (m_Logfile, Text);
	fflush (m_Logfile);

} // Textout (schwarz)

Und so wird das Logfile erstellt.

void CLogfile::CreateLogfile (const string LogName, const string Version)
{
	// Logfile leeren und Kopf schreiben
	m_Logfile = fopen (LogName.c_str(), "w");

	// Aktuelle Build-Konfiguration ausgeben
	#ifdef _DEBUG
	Textout ("BUILD: DEBUG\n");
	#else
	Textout ("BUILD: RELEASE\n");
	#endif

	// Logfile schließen und mit append wieder öffnen
	fclose (m_Logfile);
	m_Logfile = fopen (LogName.c_str(), "a");

} // CreateLogfile

Und hier der FindFileswithSubFolder und FindFileswithoutSubFolder.
Der Code ist vl. ein wenig umständlich, aber tut was er soll.

list<string> FindFileswithSubFolder(const string FileLocation)
{
	HANDLE fHandle;
	WIN32_FIND_DATA wfd;
	list<string> Result;
	list<string>::const_iterator i;
	list<string> Temp;

	fHandle = FindFirstFile((FileLocation + "\\*").c_str(),&wfd);
	if ( fHandle != INVALID_HANDLE_VALUE)
	{
		do 
		{
			// Eintrag nur behandeln, wenn es nicht . oder .. ist (werden nur bei Unterverzeichnissen mit zurückgeliefert)
			// hier könnte man z.B. auch mit lstrcmp auf . und .. vergleichen, was allerdings nicht ganz so effizient ist
			if (!( (wfd.cFileName[0]=='.') && ( (wfd.cFileName[1]=='.' && wfd.cFileName[2]==0) || wfd.cFileName[1]==0 ) ))
			{
				if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
				{
					Temp = FindFileswithSubFolder(FileLocation + "\\" + wfd.cFileName);
				}
				else
				{
					Result.push_back(FileLocation + "\\" + wfd.cFileName);
				} 
			}
			for(i = Temp.begin(); i != Temp.end(); i++)
			{
				Result.insert(Result.end(),(*i));
			}
			Temp.clear();
		}
		while (FindNextFile(fHandle,&wfd));
	}
	else
	{
		printf("%#x",GetLastError());
	}
	FindClose(fHandle);
	return Result;
}

list<string> FindFileswithoutSubFolder(const string FileLocation)
{
	HANDLE fHandle;
	WIN32_FIND_DATA wfd;
	list<string> Result;

	fHandle = FindFirstFile((FileLocation + "\\*").c_str(),&wfd);
	if ( fHandle != INVALID_HANDLE_VALUE)
	{
		do 
		{
			// Eintrag nur behandeln, wenn es nicht . oder .. ist (werden nur bei Unterverzeichnissen mit zurückgeliefert)
			// hier könnte man z.B. auch mit lstrcmp auf . und .. vergleichen, was allerdings nicht ganz so effizient ist
			if (!( (wfd.cFileName[0]=='.') && ( (wfd.cFileName[1]=='.' && wfd.cFileName[2]==0) || wfd.cFileName[1]==0 ) ))
			{
				if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
				{
					Result.push_back(FileLocation + "\\" + wfd.cFileName);
				}
			}
		}
		while (FindNextFile(fHandle,&wfd));
	}
	else
	{
		printf("%#x",GetLastError());
	}
	FindClose(fHandle);
	return Result;
}

Die Fehler Meldung kommt erst am Ende des Programms, wenn es die 5sek Slepp abgewartet hat.

g_pLogfile->fTextout ("%s\n", (*iL));

nicht kompilieren (*iL ist vom Typ string, nicht char const *).

FindFileswithoutSubFolder sieht größtenteils in Ordnung aus, obwohl ich mir gerade nicht sicher bin, wie FindClose(INVALID_HANDLE_VALUE) reagiert. Du solltest den FindClose-Aufruf fünf Zeilen nach oben verlegen.

Hier fTextout:

// fTextout
//
// Aufgabe: formatierten Text ins Logfile schreiben (schwarz)
//
void CLogfile::fTextout (const char *Text, ...)
{
	TCHAR buffer[MAX_BUFFER];  // char-Buffer
	va_list pArgList;          // Liste der übergebenen Argumente

	// String aus den Argumenten erstellen
	va_start (pArgList, Text);
	vsprintf (buffer, Text, pArgList);
	va_end (pArgList);

	// Erzeugten String schreiben
	Textout (buffer);

} // fTextout (schwarz)

// fTextout
//
// Aufgabe: formatierten Text ins Logfile schreiben (farbig)
//
void CLogfile::fTextout (int Color, const char *Text, ...)
{
	TCHAR buffer[MAX_BUFFER];  // char-Buffer
	va_list pArgList;          // Liste der übergebenen Argumente

	// String aus den Argumenten erstellen
	va_start (pArgList, Text);
	vsprintf (buffer, Text, pArgList);
	va_end (pArgList);

	// Erzeugten String schreiben
	Textout (Color, buffer);

} // fTextout (farbig)

// fTextout
//
// Aufgabe: formatierten Text ins Logfile schreiben (farbig, Liste)
//
void CLogfile::fTextout (int Color, bool List,const char *Text, ...)
{
	TCHAR buffer[MAX_BUFFER];  // char-Buffer
	va_list pArgList;          // Liste der übergebenen Argumente

	// String aus den Argumenten erstellen
	va_start (pArgList, Text);
	vsprintf (buffer, Text, pArgList);
	va_end (pArgList);

	// Erzeugten String schreiben
	Textout (Color, List, buffer);

} // fTextout (farbig, Liste)

g_pLogfile->fTextout ("%s\n", iL->c_str());

...wobei das ganze Konzept nicht besonders hübsch ist. Spricht etwas dagegen, ganz normal auf std::ostream aufzusetzen?

..wobei das ganze Konzept nicht besonders hübsch ist.

Was meinst du mit Konzept?

Spricht etwas dagegen, ganz normal auf std::ostream aufzusetzen?

Nein spricht nichts dagegen. Würde nur gerne die Vorteile von ostream wissen.

Das wären auch die Vorteile von C++-Streams.

aus Sicherheitsgründen entfernt

Bekomme ich immer noch die Fehlermeldung mit Pufferüberlauf

Textout ("PCFix " + Version + " - http://www.christian.duefel.de\nScan ");

kann das aber nicht die Textout-Funktion sein, die du hier beschrieben hast - der Ausdruck ist vom Typ std::string, nicht char const *.

Folgendes:

ostream os(&m_fb);

wird vermutlich danebengehen; std::ostreams Konstruktor nimmt als Parameter nur einen Streambuffer. Aber da m_fb schon ein std::ostream ist, kannst du einfach

m_fb << Text << "\n";

schreiben. Kompiliert der Konstruktoraufruf oben überhaupt?

m_fb << Text << "\n";

nicht gehen

Wie wäre es mit etwas C++0x:

namespace variadic {
	void print() {
		std::cout << std::endl;	
	}
	template<typename Arg, typename ... Remains>
	void print(const Arg& arg, const Remains&... remains) {
		std::cout << arg;
		print(remains...);
	}	
}

Sollte so passen. Erfordert aber ein --std=c++0x beim Kompilieren.

Und so tust du's anwenden:

variadic::print("Test ", 1, 2, 3, " okay es funktioniert!");

// Überschrift erzeugen
	g_pLogfile->WriteTopic ("Test");

	// Allocate array for getting ImageBase addresses of
    // all drivers present in system.
    DWORD dwBufferLen = GetImageBaseAddrArrayLen();
    LPVOID* pImageBaseAddrArray = (LPVOID*)new BYTE[ dwBufferLen ];

    DWORD dwBytesReturned = 0;
    // Get the ImageBaseAddresses of all drivers.
    EnumDeviceDrivers( pImageBaseAddrArray,  // array of load addresses
                       dwBufferLen,  // size of array as 0.
                       &dwBytesReturned );

    // Get the total number of drivers. calculate it by
    // total size in bytes/sizeof(void*)
    DWORD nDrivers = dwBufferLen / sizeof(LPVOID);

	PVOID OldValue = NULL;

	for( DWORD Index = 0; Index < nDrivers; ++Index )
    {
        // Get Device Driver informations.
        string sDriverBaseName;
        string sDriverFileName;
        GetDriverInfo( pImageBaseAddrArray[ Index], sDriverBaseName, sDriverFileName );

		// \??\ /
		int iFindIdxMD5Question = sDriverFileName.find( "\\??\\" );
		int iExistQuestion = 0;
		if ( iFindIdxMD5Question != -1 )
		{
			sDriverFileName.erase( 0, 4 );
			iExistQuestion = 1;
		}
		// \Windows\System32
		int iFindIdxMD5Win = sDriverFileName.find( "\\Windows\\System32" );
		if ( iFindIdxMD5Win != -1 )
			sDriverFileName.replace( iFindIdxMD5Win, 17, sSysDir );
		// \WINDOWS\System32
		int iFindIdxMD5Win2 = sDriverFileName.find( "\\WINDOWS\\System32" );
		if ( iFindIdxMD5Win2 != -1 )
			sDriverFileName.replace( iFindIdxMD5Win, 17, sSysDir );
		// \SystemRoot\System32
		int iFindIdxMD5SysRoot = sDriverFileName.find( "\\SystemRoot\\System32" );
		if ( iFindIdxMD5SysRoot != -1 )
			sDriverFileName.replace( iFindIdxMD5SysRoot, 20, sSysDir );
		// \SystemRoot\system32
		int iFindIdxMD5SysRoot2 = sDriverFileName.find( "\\SystemRoot\\system32" );
		if ( iFindIdxMD5SysRoot2 != -1 )
			sDriverFileName.replace( iFindIdxMD5SysRoot2, 20, sSysDir );
		// \SystemRoot\SysWOW64
		int iFindIdxMD5SysWOW64 = sDriverFileName.find( "\\SystemRoot" );
		if ( iFindIdxMD5SysWOW64 != -1 )
			sDriverFileName.replace( iFindIdxMD5SysWOW64, 11, sWinDir );
		// C:\Windows\SysWOW64
		int iFindIdxMD5C = sDriverFileName.find( "C:\\" );
		if ( iFindIdxMD5C == -1 )
			sDriverFileName.insert( 0, "C:\\" );

		// calculating MD5
		HANDLE hFile;
		DWORD dwNumRead = -1;

		if(IsWow64())
			if (!WOW64DisableFsRedirection(&OldValue))
				printf("WOW64DisableFsRedirection doesn´t work\n");

		hFile = CreateFile(sDriverFileName.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

		if (!WOW64RevertFsRedirection(OldValue))
			printf("WOW64RevertFsRedirection doesn´t work\n");

		if(hFile == INVALID_HANDLE_VALUE)
		{
			g_pLogfile->Textout ("ERROR: INVALID_HANDLE_VALUE" + sDriverFileName);
		}
		else
		{
			//GetFileSize to determine size of buffer for ReadFile
			DWORD BufferSize = GetFileSize(hFile,NULL);

			cout << "Buffer: " << BufferSize <<endl;

			char* ReadBuffer = new char [BufferSize];// create a new char * to hold the buffer using the filesize

			//Read from the file:
			if(!ReadFile(hFile, ReadBuffer,BufferSize+1,&dwNumRead,NULL))
			{
				printf ("ReadFile Fail");
				return 1;
			}

			//To close the file:
			CloseHandle(hFile);

			char hash[32];
			MD5Hash((BYTE*)ReadBuffer,BufferSize,hash);
			free(ReadBuffer);
			if ( iExistQuestion == 1)
			sDriverFileName.insert( 0, "\\??\\");

			g_pLogfile->Textout (sDriverBaseName + " : " + sDriverFileName + " : " + hash);

		}
    }

MD5.cpp

#include <iostream>
#include <windows.h>
#include <wincrypt.h>
#include <fstream>

using namespace std;

#define MD5LEN  16

void MD5Hash(BYTE hash[],int sz,char sec[])
{
    HCRYPTPROV hProv = 0,hHash = 0;
    BYTE rgbHash[MD5LEN];
    DWORD cbHash = 0;
    char finalhash[32], dig[] = "0123456789abcdef";
    unsigned int l = 0;

    CryptAcquireContext(&hProv, NULL,NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
    CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
    CryptHashData(hHash, hash, sz, 0);
    cbHash = MD5LEN;
    CryptGetHashParam(hHash, HP_HASHVAL, rgbHash, &cbHash, 0);

    for(DWORD i = 0; i < cbHash; i++){
        finalhash[l] = dig[rgbHash[i] >> 4];
        l++;
        finalhash[l] = dig[rgbHash[i] & 0xf];
        l++;
    }

    for(l = 32; l < strlen(finalhash); l++) finalhash[l] = 0;
    strcpy_s(sec, 33, finalhash);
    CryptDestroyHash(hHash);
    CryptReleaseContext(hProv, 0);
}

DLL_LoadFunction.h

#include <windows.h>

typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
typedef BOOL (WINAPI *LPFN_WOW64DISABLEWOW64FSREDIRECTION) (PVOID*);
typedef BOOL (WINAPI *LPFN_WOW64REVERTWOW64FSREDIRECTION) (PVOID);

BOOL IsWow64();
BOOL WOW64DisableFsRedirection(PVOID *OldValue);
BOOL WOW64RevertFsRedirection(PVOID OldValue);

DLL_LoadFunction.cpp

#include "DLL_LoadFunction.h"

LPFN_ISWOW64PROCESS fnMyIsWow64Process;
LPFN_WOW64DISABLEWOW64FSREDIRECTION fnMyWow64DisableWow64FsRedirection;
LPFN_WOW64REVERTWOW64FSREDIRECTION fnMyWow64RevertWow64FsRedirection;

BOOL IsWow64()
{
    BOOL bIsWow64 = FALSE;

    //IsWow64Process is not available on all supported versions of Windows.
    //Use GetModuleHandle to get a handle to the DLL that contains the function
    //and GetProcAddress to get a pointer to the function if available.

    fnMyIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
        GetModuleHandle(TEXT("kernel32")),"IsWow64Process");

    if(NULL != fnMyIsWow64Process)
    {
        if (!fnMyIsWow64Process(GetCurrentProcess(),&bIsWow64))
        {
            //handle error
        }
    }
    return bIsWow64;
}

BOOL WOW64DisableFsRedirection(PVOID *OldValue)
{
	fnMyWow64DisableWow64FsRedirection = (LPFN_WOW64DISABLEWOW64FSREDIRECTION) GetProcAddress(
		GetModuleHandle(TEXT("kernel32")),"Wow64DisableWow64FsRedirection");

	if(NULL != fnMyWow64DisableWow64FsRedirection)
	{
		if (!fnMyWow64DisableWow64FsRedirection(OldValue))
		{
			// handel error
			return false;
		}
		else
		{
			return true;
		}
	}
	return false;
}

BOOL WOW64RevertFsRedirection(PVOID OldValue)
{
	fnMyWow64RevertWow64FsRedirection = (LPFN_WOW64REVERTWOW64FSREDIRECTION) GetProcAddress(
		GetModuleHandle(TEXT("kernel32")),"Wow64RevertWow64FsRedirection");

	if(NULL != fnMyWow64RevertWow64FsRedirection)
	{
		if (!fnMyWow64RevertWow64FsRedirection(OldValue))
		{
			// handel error
			return false;
		}
		else
		{
			return true;
		}
	}
	return false;
}

Wenn wer Fehler oder Optimierungsbedarf sieht immer her damit

LPVOID* pImageBaseAddrArray = (LPVOID*)new BYTE[ dwBufferLen ];

Wo gibst du den Speicher frei? Vergiss nicht, ihn vor dem delete[] in BYTE* zu casten.

int iFindIdxMD5Win = sDriverFileName.find( "\\Windows\\System32" );
if ( iFindIdxMD5Win != -1 ) 
            sDriverFileName.replace( iFindIdxMD5Win, 17, sSysDir ); 
// [Noch 5 Mal Codeduplikation]

Auslagern in Funktionen wäre angebracht.

char* ReadBuffer = new char [BufferSize];
// [...]
free(ReadBuffer);

Das resultiert in undefiniertem Verhalten. Niemals new / delete mit malloc() / free() mischen**!**

In C++ solltest du primär new / delete bzw. new[] / delete[] verwenden. Noch besser wäre natürlich automatische Speicherverwaltung mittels RAII. Gut möglich, dass hier auch dein Fehler liegt.

#define MD5LEN  16

Ziehe für Konstanten const typ einem #define vor.

Vielen Dank für deine Hilfe, Nexus

Jetzt bekomme ich folgende Fehlermeldung:

Run-Time Check Failure #2 - Stack around the variable 'finalhash' was corrupted.

#include <iostream>
#include <windows.h>
#include <wincrypt.h>
#include <fstream>

using namespace std;

const int MD5LEN = 16;

void MD5Hash(BYTE hash[],int sz,char sec[])
{
    HCRYPTPROV hProv = 0,hHash = 0;
    BYTE rgbHash[MD5LEN];
    DWORD cbHash = 0;
    char finalhash[32], dig[] = "0123456789abcdef";
    unsigned int l = 0;

    CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
    CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
    CryptHashData(hHash, hash, sz, 0);
    cbHash = MD5LEN;
    CryptGetHashParam(hHash, HP_HASHVAL, rgbHash, &cbHash, 0);

    for(DWORD i = 0; i < cbHash; i++){
        finalhash[l] = dig[rgbHash[i] >> 4];
        l++;
        finalhash[l] = dig[rgbHash[i] & 0xf];
        l++;
    }

    for(l = 32; l < strlen(finalhash); l++) finalhash[l] = 0;
    strcpy_s(sec, 33, finalhash);
    CryptDestroyHash(hHash);
    CryptReleaseContext(hProv, 0);
}

Ich hoffe hier kann mir auch nochmal wer auf die Sprünge helfen

Für Arrays konstanter Grösse könntest du z.B. std::tr1::array nehmen (falls du TR1 hast, sonst gäbe es das auch in Boost). Ist im Release-Modus genauso schnell wie ein C-Array, aber prüft im Debug-Modus Indizes und spart viel Debugzeit. Hat auch nützliche Methoden wie size() , sodass die Grösse nicht immer separat abgespeichert werden muss. Für dynamische Puffer kannst du statt mit new[] und delete[] selbst was zu basteln Containerklassen wie std::vector nehmen. Die Schnittstelle ist bei array und vector weitgehend einheitlich.

// std::vector für dynamisches Array, als Beispiel
    std::vector<BYTE> hash;

    // std::tr1::array für statisches Array
    std::tr1::array<char, 32> finalhash;

    hash[index]; // zugreifen auf Elemente (beide Container)
    &hash[0]; // erhalten eines C-Strings für WinAPI-Interoperabilität

    // Statt deiner Schleife, nimm sowas (hat auch nicht quadratische Laufzeit):
    // Variablen wie l erst wenn nötig deklarieren!
    for(unsigned int l = 0; l < finalhash.size(); ++l)
		finalhash[l] = 0;

    // Oder gleich so:
    std::fill(finalhash.begin(), finalhash.end(), 0);    

    // Statt strcpy_s kannst du z.B. std::copy() nehmen
    std::copy(finalhash.begin(), finalhash.end(), sec.begin());

    // Oder meinetwegen auch so, ohne hardgecodete Literale wie 33
    strcpy_s(&sec[0], sec.size(), finalhash);

Lies dich vielleicht auf www.cplusplus.com in die Dokumentation der STL-Container und -Algorithmen etwas ein. Einen schönen Artikel findest du auch hier.