C / C++ / MFC

zon_cpp wrote:

is any other reason?

ryan2189 wrote:

Does a DLL also have an IAT in which it holds function pointers that it used from another DLL

int myfunc(buffer* pszBuffer)
{
// fill buffer with information
    return 1;
}

char* nbuff = new char[64];
int val = myfunc(nbuff);
// do other things
delete[] nbuff; // finished with this buffer

jkirkerx wrote:

I build a class to encrypt and decrypt, but when I use the function multiple times, it changes the values of the previous buffers I stored the values in.

WCHAR*	CA_Encryption::_encrypt_3DES( WCHAR *pzInputW )
{
BOOL			bResult = FALSE;
WCHAR			*szOutput = NULL;
 
HCRYPTPROV		hProv;
HCRYPTKEY		hKey;
ALG_ID			Algid;
PBYTE			pbKeyBlob = NULL; 
BYTE			*pbBuffer;
DWORD			dwBlockLen = 0;
DWORD			dwDataLen = 0;
DWORD			cbData = 0;
BOOL			bFinal = TRUE;
DWORD			errorCode = 0;

DWORD			dwResult = 0;
TCHAR			szBase64[80];
DWORD			cbKeyLen = 24;
	 
// Get the size of the conversion first
int iCharA = WideCharToMultiByte(CP_UTF8, 0, pzInputW, -1, NULL, 0, NULL, NULL);	
char *szInputA = new char[iCharA];
WideCharToMultiByte(CP_UTF8, 0, pzInputW, -1, szInputA, iCharA, NULL, NULL);

keyBlob192.hdr.bType = PLAINTEXTKEYBLOB;
keyBlob192.hdr.bVersion = CUR_BLOB_VERSION;
keyBlob192.hdr.reserved = 0;
keyBlob192.hdr.aiKeyAlg = CALG_3DES;
keyBlob192.cbKeySize = 24;
ZeroMemory(keyBlob192.rgbKeyData, 24);
CopyMemory(keyBlob192.rgbKeyData, KEY_192, cbKeyLen > 24 ? 24 : cbKeyLen);
			
bResult = CryptAcquireContextW( &hProv, 0, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
bResult = CryptImportKey(hProv, (BYTE*)&keyBlob192, sizeof(keyBlob192), 0, CRYPT_EXPORTABLE, &hKey);	
bResult = CryptSetKeyParam(hKey, KP_IV, IV_64, 0);
		
dwDataLen = sizeof(ALG_ID);
cbData = sizeof(szInputA);	

if (!CryptGetKeyParam(hKey, KP_ALGID, (BYTE *)&Algid, &dwDataLen, 0)) 
	return 0;
	
if (GET_ALG_TYPE(Algid) != ALG_TYPE_STREAM) {		
	dwDataLen = sizeof(DWORD);		
	if (!CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE *)&dwBlockLen, &dwDataLen, 0))
	  return 0;		
	dwDataLen = ((cbData + dwBlockLen - 1) / dwBlockLen) * dwBlockLen;		
	if (!(pbBuffer = (BYTE *)LocalAlloc(LMEM_FIXED, dwDataLen))) 
		return 0;
	} 
	else {
		if (!(pbBuffer = (BYTE *)LocalAlloc(LMEM_FIXED, cbData))) 
			return 0;
	}	  
	CopyMemory(pbBuffer, szInputA, cbData);
	if (!CryptEncrypt(hKey, 0, bFinal, 0, pbBuffer, &cbData, dwDataLen)) {
		DWORD dwError = GetLastError();		
		if(ERROR_MORE_DATA == dwError) {
			DWORD dwSizeNeeded = cbData;
			CopyMemory( pbBuffer, szInputA, cbData );
			bResult = CryptEncrypt(hKey, 0, FALSE, 0, pbBuffer, &dwSizeNeeded, dwDataLen);
		}			
		LocalFree(pbBuffer);
		return 0;
}	
	
if(CryptBinaryToString(pbBuffer, 8, CRYPT_STRING_BASE64, NULL, &dwResult)) {		
	CryptBinaryToString(pbBuffer, 8, CRYPT_STRING_BASE64, szBase64, &dwResult);
	szBase64[dwResult] = 0;
	szOutput = (WCHAR*)szBase64;
	szOutput[wcslen(szOutput)+1] = L'\0';
}	

// Secure sensitive data in buffers
SecureZeroMemory( keyBlob64.rgbKeyData, 8 );
SecureZeroMemory( pbBuffer, sizeof(pbBuffer) );
	
// Clean up the garbage in the heap
delete [] szInputA;

CryptDestroyKey(hKey);
CryptReleaseContext(hProv, 0);	
	
return szOutput;
}

BYTE* CA_Encryption::_create_MD5_Hash( WCHAR *pzInputW )
{
BOOL			bResult = FALSE;
HCRYPTPROV		hProv;
HCRYPTHASH		hHash;

const int		MD5_SIZE = 16;
static BYTE		hash[MD5_SIZE];
DWORD			hash_size = sizeof(hash);	
			
// Get the size of the conversion
int iChar = WideCharToMultiByte(CP_UTF8, 0, pzInputW, -1, NULL, 0, NULL, NULL);	
char *szInputA = new char[iChar];
WideCharToMultiByte(CP_UTF8, 0, pzInputW, -1, szInputA, iChar, NULL, NULL);
		
DWORD		dwBufferSize = 0;	
DWORD		dwPasswordLen = strlen((char *)szInputA);	
		
bResult = CryptAcquireContextW( &hProv, NULL, MS_STRONG_PROV, PROV_RSA_FULL, 0);	
bResult = CryptCreateHash( hProv, CALG_MD5, 0, 0, &hHash );   
bResult = CryptHashData( hHash, (BYTE*)szInputA, dwPasswordLen, 0 );
	
// Now get the value
bResult = CryptGetHashParam( hHash, HP_HASHVAL, hash, &hash_size, 0 );
		
// Release hash object.
delete [] szInputA;
CryptDestroyHash(hHash);
CryptReleaseContext(hProv, 0);
		    	
return hash;
}