C / C++ / MFC

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;
}

DWORD dwSecretAnwser;
caEncrypt._encrypt_3DES(szSecretAnwser, dwSecretAnwser);
WCHAR *szSecretAnwser_Secure = 	new WCHAR[dwSecretAnwser];
szSecretAnwser_Secure = caEncrypt._encrypt_3DES(szSecretAnwser, dwSecretAnwser);

WCHAR* CA_Encryption::_encrypt_3DES( WCHAR *pzInputW, DWORD &dwOutput )
{
	BOOL			bResult = FALSE;
	 
	HCRYPTPROV		hProv;
	HCRYPTKEY		hKey;
	ALG_ID			Algid;
	PBYTE			pbKeyBlob = NULL; 
    BYTE			*pbBuffer;
	DWORD			dwBlockLen = 0;
	DWORD			dwDataLen = 0;
	DWORD			cbData;
	BOOL			bFinal = TRUE;
	DWORD			errorCode = 0;
	TCHAR			*szBase64 = NULL;
	DWORD			dwResult;
	DWORD			cbKeyLen = sizeof(KEY_192);
	 
	// Get the size of the conversion first
	int iCharA = (WideCharToMultiByte(CP_UTF8, 0, pzInputW, -1, NULL, 0, NULL, NULL) - 1);	
	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 = sizeof(KEY_192);
	CopyMemory(keyBlob192.rgbKeyData, KEY_192, cbKeyLen>  sizeof(keyBlob192) ? sizeof(keyBlob192) : 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_192, 0);
		
	dwDataLen = sizeof(ALG_ID);
	cbData = iCharA;

	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)) {
			LocalFree(pbBuffer);
			return 0;
	}

	// Secure sensitive data in buffers
	SecureZeroMemory( keyBlob192.rgbKeyData, sizeof(keyBlob192.rgbKeyData) );
		
	// Clean up the garbage in the heap
	delete [] szInputA;
	CryptDestroyKey(hKey);
	CryptReleaseContext(hProv, 0);	

	if(CryptBinaryToString((BYTE*)pbBuffer, cbData, CRYPT_STRING_BASE64, NULL, &dwResult)) {		
		if  ((dwOutput > 0 ) && (dwOutput < 4096)) {
			szBase64 = new TCHAR[dwResult];
			CryptBinaryToString((BYTE*)pbBuffer, cbData, CRYPT_STRING_BASE64, szBase64, &dwResult);
			dwOutput = dwResult;
			szBase64[dwResult-2] = 0;
			return szBase64;
		}
		else {			
			dwOutput = dwResult;
			return L'\0';
		}				
	}
	else {
		dwOutput = dwResult;
		return L'\0';
	}	
}

softwaremonkey wrote:

I thought about upgrading but its too much hassle re-installing everything.