C / C++ / MFC

jkirkerx wrote:

You code sample is what I was looking for.

jkirkerx wrote:

Can I replace LPCBYTE with BYTE*

jkirkerx wrote:

I added odbcss.h, but it adds a bunch of sql server stuff that I don't need.

jkirkerx wrote:

Would Password be my KEY_192 with 24 bytes?

So I can add my IV_192 using CreateKeyParam?

BYTE	KEY_192[24]	= {42, 16, 93, 156, 78, 4, ...
BYTE	IV_192[24]	= {55, 103, 246, 79, 36, ...

CryptAcquireContext(&hProv, NULL, MS_STRONG_PROV, PROV_RSA_FULL, 0);
CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
CryptHashData(hHash, KEY_192, pwlen would be 24, 0);
CryptDeriveKey(hProv, CALG_3DES, hHash, 0, &hKey);
CryptSetKeyParam(hKey, KP_IV, IV_192, 0);

jkirkerx wrote:

Your example is very similar to what I wrote the 4th time, except you had the Base64 piece that I needed.

jkirkerx wrote:

Side question, How do get the length of a BYTE* for pwlen

CryptHashData(hHash, KEY_192, sizeof(KEY_192), 0);

WCHAR*	CA_Encryption::_encrypt_DES( WCHAR *pzInput )
{
	BOOL			bResult = FALSE;
	WCHAR			*szOutput = NULL;

	DWORD cbKey64	= sizeof(KEY_64);
	HCRYPTPROV		hProv;
	HCRYPTHASH		hHash = NULL;
	HCRYPTKEY		hKey = NULL;

	const int		DES_SIZE = 64;
	static BYTE		hash[DES_SIZE];
	DWORD			buffer_size = sizeof(hash);
	DWORD			buffer_length;		

	// Get the size of the conversion
	int iChar = WideCharToMultiByte(CP_UTF8, 0, pzInput, -1, NULL, 0, NULL, NULL);	
	char *szInput = new char[iChar];
	WideCharToMultiByte(CP_UTF8, 0, pzInput, -1, szInput, iChar, NULL, NULL);
	
	// Aquire a handle the Encryption provider
	bResult = CryptAcquireContextW( &hProv, 0, MS_STRONG_PROV, PROV_RSA_FULL, 0);
	bResult = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
	bResult = CryptHashData(hHash, KEY_64, sizeof(KEY_64), 0);	
	bResult = CryptDeriveKey(hProv, CALG_DES, hHash, 0, &hKey);
	bResult = CryptSetKeyParam(hKey, KP_IV, IV_64, 0);

	// Get the size of the buffer
	buffer_length = strlen((char *)szInput);	
	BYTE *szBuffer = new BYTE[64];
	memcpy( szBuffer, (BYTE*)szInput, sizeof(szInput) );
	delete [] szInput;

	// Get the size of the hash and length
	bResult = CryptEncrypt(hKey, 0, FALSE, 0, szBuffer, &buffer_size, buffer_length);	
	
			
	CryptDestroyKey(hKey);
	CryptDestroyHash(hHash);
	CryptReleaseContext(hProv, 0);	
	
	return szOutput;
}

Public Shared Function Encrypt(ByVal value As String) As String
        If value <> "" Then
            Dim cryptoProvider As DESCryptoServiceProvider = New DESCryptoServiceProvider()
            Dim ms As MemoryStream = New MemoryStream()
            Dim cs As CryptoStream = New CryptoStream(ms, cryptoProvider.CreateEncryptor(KEY_64, IV_64), _
            CryptoStreamMode.Write)
            Dim sw As StreamWriter = New StreamWriter(cs)

            sw.Write(value)
            sw.Flush()
            cs.FlushFinalBlock()
            ms.Flush()

            'convert back to a string
            Return Convert.ToBase64String(ms.GetBuffer(), 0, ms.Length)
        Else
            Encrypt = ""
        End If

    End Function

jkirkerx wrote:

I get a value back that's sort or weird. It works, but I think the size of my buffer is too large.

 

R㏾΂ò.¢Ó`Ï­<oÝV|63¾ˆWãÔZ÷(šœ(è~Ó¥¶ãòõ¬"oÌtðaÏMûÏþƒÝÌXðýýýý««««««««îþîþîþîþîþîþ

szBuffer[buffer_size] = 0;

jkirkerx wrote:

I'm trying to get a perfect match on my encryption program, so it matches my asp.net version. It looks like the code you approved actually works correctly, and I'm down to the Base64 part.

jkirkerx wrote:

Is there a difference between your Base64Encode function and the function on this page?

http://msdn.microsoft.com/en-us/library/dhx0d524.aspx[^]

TCHAR pByteLF = *(LPWORD)(lpszBase64 + dwResult -1);
TCHAR pByteCR = *(LPWORD)(lpszBase64 + dwResult -2);
if(pByteCR == 0x0D && pByteLF == 0x0A)
{
	*(LPWORD)(lpszBase64 + dwResult -2) = 0;
}

if(TRUE == bStripCRLF)
{
	TCHAR pByteLF = *(LPWORD)(lpszBase64 + dwResult -1);
	TCHAR pByteCR = *(LPWORD)(lpszBase64 + dwResult -2);
	if(pByteCR == 0x0D && pByteLF == 0x0A)
	{
		*(LPWORD)(lpszBase64 + dwResult -2) = 0;
	}
}

jkirkerx wrote:

It's either this MS_ENHANCED_PROV, PROV_RSA_FULL, or the key not being in the right format, or perhaps 5 other possibilities.

Public Shared Function Encrypt(ByVal value As String) As String
        If value <> "" Then

            Dim cryptoProvider As DESCryptoServiceProvider = New DESCryptoServiceProvider()
            Dim ms As MemoryStream = New MemoryStream()
            Dim cs As CryptoStream = New CryptoStream(ms, cryptoProvider.CreateEncryptor(KEY_64, IV_64), _
            CryptoStreamMode.Write)
            Dim sw As StreamWriter = New StreamWriter(cs)

            sw.Write(value)
            sw.Flush()
            cs.FlushFinalBlock()
            ms.Flush()

            'convert back to a string
            Return Convert.ToBase64String(ms.GetBuffer(), 0, ms.Length)
        Else
            Encrypt = ""
        End If

    End Function

Public Shared Function _encrypt_DES(ByVal szInputW As String) As String

        Dim szOutput As String = Nothing
        Dim szBufferIn() As Byte = Nothing
        Dim szBufferOut() As Byte = Nothing

        If szInputW <> "" Then
            Dim cryptoProvider As DESCryptoServiceProvider = New DESCryptoServiceProvider()
            With cryptoProvider
                .BlockSize = 64
                .FeedbackSize = 8
                .Key = KEY_64
                .IV = IV_64
                .Mode = CipherMode.CBC
                .Padding = PaddingMode.PKCS7
            End With

            Dim symAlg As SymmetricAlgorithm = cryptoProvider
            Dim xfrm As ICryptoTransform = Nothing

            szBufferIn = UTF8Encoding.UTF8.GetBytes(szInputW)
            xfrm = symAlg.CreateEncryptor()

            szBufferOut = xfrm.TransformFinalBlock(szBufferIn, 0, szBufferIn.Length)
            szOutput = Convert.ToBase64String(szBufferOut, 0, szBufferOut.Length)

        Else
            szOutput = ""
        End If

        Return szOutput

    End Function

jkirkerx wrote:

.Padding = PaddingMode.PKCS7

DWORD dwPadding = 0;
DWORD dwLength = sizeof(DWORD);
bResult = CryptGetKeyParam(hKey,KP_PADDING,(BYTE *)&dwPadding,&dwLength,0);

Dim cryptoProvider As DESCryptoServiceProvider = New DESCryptoServiceProvider()
With cryptoProvider
    .BlockSize = 64
    .FeedbackSize = 8
    .Key = KEY_64
    .IV = IV_64
    .Mode = CipherMode.CBC
    .Padding = PaddingMode.PKCS7
End With

DWORD dwMode = CRYPT_MODE_CBC;
bResult = CryptSetKeyParam(hKey, KP_MODE,(BYTE *)&dwMode, 0);

DWORD dwPadding = PKCS5_PADDING;
bResult = CryptSetKeyParam(hKey, KP_PADDING,(BYTE *)&dwPadding, 0);

BYTE IV_64[8] = {1, 2, 3, 4, 5, 6, 7, 8}; //Replace my magic numbers with your own
CryptSetKeyParam(hKey, KP_IV, IV_64, 0);

DWORD dwFeedback = 8;
bResult = CryptSetKeyParam(hKey, KP_MODE_BITS,(BYTE *)&dwFeedback, 0);

DWORD dwBlockLength = 64;
bResult = CryptSetKeyParam(hKey, KP_BLOCKLEN,(BYTE *)&dwBlockLength, 0);

// Aquire a handle to the Encryption provider
	bResult = CryptAcquireContextW( &hProv, 0, MS_ENHANCED_PROV, PROV_RSA_FULL, 0);
	bResult = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
	
	// hProv - Program Key
	bResult = CryptHashData(hHash, KEY_64, sizeof(KEY_64), 0);
	bResult = CryptDeriveKey(hProv, CALG_DES, hHash, 0, &hKey);
	
	// hProv - Block Length
	DWORD dwBlockLength = 64;
	bResult = CryptSetKeyParam(hKey, KP_BLOCKLEN, (BYTE *)&dwBlockLength, 0);

	// Feedback Size
	DWORD dwFeedback = 8;
	bResult = CryptSetKeyParam(hKey, KP_MODE_BITS, (BYTE*)&dwFeedback, 0);
	errorCode = GetLastError();
	
	// hProv - IV
	bResult = CryptSetKeyParam(hKey, KP_IV, IV_64, 0);
	errorCode = GetLastError();
	
	// hProv - CBC Mode
	DWORD dwMode = CRYPT_MODE_CBC;
	bResult = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
	errorCode = GetLastError();

	// hProv Padding
	DWORD dwSetPadding = PKCS5_PADDING;
	bResult = CryptSetKeyParam(hKey, KP_PADDING, (BYTE *)&dwSetPadding, 0);
	errorCode = GetLastError();

jkirkerx wrote:

I give up.

// VB Keys Returned
//BYTE  KEY_64[8]   = {90, 186, 171, 206, 25, 142, 74, 177};
//BYTE  IV_64[8]    = {5, 164, 38, 94, 172, 125, 164, 28};

// My Keys
BYTE    KEY_64[8]   = {42, 16, 93, 156, 78, 4, 218, 32};
BYTE    IV_64[8]    = {55, 103, 246, 79, 36, 99, 167, 3};

jkirkerx wrote:

Your VB code isn't hashing or deriving anything. You are likely looking for CryptImportKey. That's how you obtain HCRYPTKEY handle from raw key material.

jkirkerx wrote:

PKCS 5 and PKCS 7 specify the same padding algorithm. Your problem has nothing to do with padding, and is most likely due to the fact that you are encrypting with different keys

jkirkerx wrote:

Food for thought, just not sure how to proceed.

bResult = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
bResult = CryptHashData(hHash, KEY_64, sizeof(KEY_64), 0);

bResult = CryptImportKey(hProv, KEY_64, sizeof(KEY_64), &hKey, 0, &hKey);

BYTE DesKeyBlob_64[] = {
0x08,0x02,0x00,0x00,0x01,0x66,0x00,0x00, // BLOB header
0x08,0x00,0x00,0x00,                     // key length, in bytes
0xf1,0x0e,0x25,0x7c,0x6b,0xce,0x0d,0x34  // DES key with parity
};

// My Keys
BYTE    KEY_64[8]   = {42, 16, 93, 156, 78, 4, 218, 32};
BYTE    IV_64[8]    = {55, 103, 246, 79, 36, 99, 167, 3};

<pre>
// Aquire a handle to the Encryption provider
bResult = CryptAcquireContextW( &hProv, 0, MS_ENHANCED_PROV, PROV_RSA_FULL, 0);
	
// hProv - Set the Key
bResult = CryptImportKey(hProv, DesKeyBlob_64, sizeof(DesKeyBlob_64), 0, CRYPT_EXPORTABLE, &hKey);

// hProv - Set the Algorithm
bResult = CryptSetKeyParam(hKey, KP_ALGID, (BYTE*)CALG_DES, 0);
			
// hProv - IV
bResult = CryptSetKeyParam(hKey, KP_IV, IV_64, 0);

jkirkerx wrote:

BYTE DesKeyBlob_64[] = {
0x08,0x02,0x00,0x00,0x01,0x66,0x00,0x00, // BLOB header
0x08,0x00,0x00,0x00, // key length, in bytes
0xf1,0x0e,0x25,0x7c,0x6b,0xce,0x0d,0x34 // DES key with parity
};

// Link with the Advapi32.lib file.
#pragma comment (lib, "advapi32")
#pragma comment(lib, "crypt32.lib")
	
	BYTE DesKeyBlob_64[] = {
    0x08,0x02,0x00,0x00,0x01,0x66,0x00,0x00,	// BLOB header 
    0x08,0x00,0x00,0x00,						// key length, in bytes
    0x2a,0x10,0x5D,0x9C,0x4E,0x4,0xDA,0x20		// DES key with parity
    };	
		
WCHAR*	_encrypt_DES( WCHAR *pzInputW )
{
	BOOL			bResult = FALSE;
	WCHAR			*szOutput = NULL;
 
	HCRYPTPROV		hProv;
	HCRYPTKEY		hKey;
	ALG_ID			Algid;
	PBYTE			pbKeyBlob = NULL; 
    DWORD			dwKeyBlobLen;	
	BYTE			*pbBuffer;
	DWORD			dwBlockLen = 0;
	DWORD			dwDataLen = 0;
	DWORD			errorCode = 0;
	DWORD			cbData = 0;
	BOOL			bFinal = TRUE;
	 
	// 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);
			
	// Aquire a handle to the Encryption provider
	bResult = CryptAcquireContextW( &hProv, 0, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
	// hProv - Set the Key
	bResult = CryptImportKey(hProv, DesKeyBlob_64, sizeof(DesKeyBlob_64), 0, CRYPT_EXPORTABLE, &hKey);	
	// hProv - IV
	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;
	}

	// Peek inside the buffer before Binary to String
	BYTE szByte[8];
	for (int i = 0; i < cbData; ++i) {
		szByte[i] = (BYTE)pbBuffer[i];
	}				
	
	DWORD dwResult = 0;
	TCHAR *szBase64 = NULL;		
	if(CryptBinaryToString((BYTE*)pbBuffer, 8, CRYPT_STRING_BASE64, NULL, &dwResult)) {		
		szBase64 = new TCHAR[dwResult];		
		CryptBinaryToString((BYTE*)pbBuffer, 8, CRYPT_STRING_BASE64, szBase64, &dwResult);			
		szOutput = (WCHAR*)szBase64;
		delete [] szBase64;
	}	

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

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