Cryptography.cpp

Go to the documentation of this file.

#include "Cryptography.h"

#include <WinSock2.h>
#include <WS2tcpip.h>
#include <Windows.h>

#include <cstdlib>

#include <wincrypt.h>

bool Cryptography::SetupCryptoClient()
{
        // Ensure that the default cryptographic client is set up.      
        HCRYPTPROV hProv;
        HCRYPTKEY hKey;
        // Attempt to acquire a handle to the default key container.
        if (!CryptAcquireContext(&hProv, nullptr, MS_DEF_PROV, PROV_RSA_FULL, 0))
        {
                // Some sort of error occured, create default key container.
                if (!CryptAcquireContext(&hProv, nullptr, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_NEWKEYSET))
                {
                        // Error creating key container!                        
                        return false;
                }
        }
        // Attempt to get handle to signature key.
        if (!CryptGetUserKey(hProv, AT_SIGNATURE, &hKey))
        {
                if (GetLastError() == NTE_NO_KEY)
                {
                        // Create signature key pair.
                        if (!CryptGenKey(hProv, AT_SIGNATURE, 0, &hKey))
                        {
                                // Error during CryptGenKey!                            
                                CryptReleaseContext(hProv, 0);
                                return false;
                        }
                        else
                        {
                                CryptDestroyKey(hKey);
                        }
                }
                else
                {
                        // Error during CryptGetUserKey!                        
                        CryptReleaseContext(hProv, 0);
                        return false;
                }
        }

        // Attempt to get handle to exchange key.
        if (!CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hKey))
        {
                if (GetLastError() == NTE_NO_KEY)
                {
                        // Create key exchange key pair.
                        if (!CryptGenKey(hProv, AT_KEYEXCHANGE, 0, &hKey))
                        {
                                // Error during CryptGenKey!                            
                                CryptReleaseContext(hProv, 0);
                                return false;
                        }
                        else
                        {
                                CryptDestroyKey(hKey);
                        }
                }
                else
                {
                        // Error during CryptGetUserKey!                        
                        CryptReleaseContext(hProv, 0);
                        return false;
                }
        }

        CryptReleaseContext(hProv, 0);
        return true;
}

bool Cryptography::EncryptString(char* szPassword, char* szEncryptPwd, char *szKey)
{
        bool bResult = true;
        HCRYPTPROV hProv = NULL;
        HCRYPTKEY hKey = NULL;
        HCRYPTHASH hHash = NULL;
        // Get handle to user default provider.
        if (CryptAcquireContext(&hProv, nullptr, nullptr, PROV_RSA_FULL, 0))
        {
                // Create hash object.          
                if (CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash))
                {
                        // Hash password string.                        
                        DWORD dwLength = strlen(szKey);
                        if (CryptHashData(hHash, reinterpret_cast<BYTE *>(szKey), dwLength, 0))
                        {
                                // Create block cipher session key based on hash of the password.
                                if (CryptDeriveKey(hProv, MY_ENCRYPT, hHash, CRYPT_EXPORTABLE, &hKey))
                                {
                                        // Determine number of bytes to encrypt at a time.
                                        dwLength = strlen(szPassword);
                                        // Allocate memory.
                                        BYTE *pbBuffer = static_cast<BYTE *>(malloc(dwLength));
                                        if (pbBuffer != nullptr)
                                        {
                                                memcpy(pbBuffer, szPassword, dwLength);
                                                // Encrypt data
                                                if (CryptEncrypt(hKey, 0, true, 0, pbBuffer, &dwLength, dwLength))
                                                {
                                                        // return encrypted string
                                                        memcpy(szEncryptPwd, pbBuffer, dwLength);
                                                        szEncryptPwd[dwLength] = 0;
                                                }
                                                else
                                                {
                                                        bResult = false;
                                                }
                                                // Free memory
                                                free(pbBuffer);
                                        }
                                        else
                                        {
                                                bResult = false;
                                        }
                                        CryptDestroyKey(hKey);  // Release provider handle.                             
                                }
                                else
                                {
                                        // Error during CryptDeriveKey!                                 
                                        bResult = false;
                                }
                        }
                        else
                        {
                                // Error during CryptHashData!                          
                                bResult = false;
                        }
                        CryptDestroyHash(hHash);
                        // Destroy session key.         
                }
                else
                {
                        // Error during CryptCreateHash!                        
                        bResult = false;
                }
                CryptReleaseContext(hProv, 0);
        }

        return bResult;
}

bool Cryptography::DecryptString(char* szEncryptPwd, char* szPassword, char *szKey)
{
        bool bResult = true;
        HCRYPTPROV hProv = NULL;
        HCRYPTKEY hKey = NULL;
        HCRYPTHASH hHash = NULL;
        char szPasswordTemp[16];
        szPasswordTemp[0] = 0;
        // Get handle to user default provider.
        if (CryptAcquireContext(&hProv, nullptr, nullptr, PROV_RSA_FULL, 0))
        {
                // Create hash object.                  
                if (CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash))
                {
                        // Hash password string.
                        DWORD dwLength = strlen(szKey);
                        if (CryptHashData(hHash, reinterpret_cast<BYTE *>(szKey), dwLength, 0))
                        {
                                // Create block cipher session key based on hash of the password.
                                if (CryptDeriveKey(hProv, MY_ENCRYPT, hHash, CRYPT_EXPORTABLE, &hKey))
                                {
                                        // we know the encrypted password and the length
                                        dwLength = strlen(szEncryptPwd);
                                        // copy encrypted password to temporary TCHAR
                                        strcpy_s(szPasswordTemp, 16, szEncryptPwd);
                                        if (!CryptDecrypt(hKey, 0, true, 0, reinterpret_cast<BYTE *>(szPasswordTemp), &dwLength))
                                                bResult = false;
                                        CryptDestroyKey(hKey);  // Release provider handle.                                     
                                        // copy decrypted password to outparameter
                                        strcpy_s(szPassword, 16, szPasswordTemp);
                                }
                                else
                                {
                                        // Error during CryptDeriveKey!                                         
                                        bResult = false;
                                }
                        }
                        else
                        {
                                // Error during CryptHashData!                                  
                                bResult = false;
                        }
                        CryptDestroyHash(hHash); // Destroy session key.                        
                }
                else
                {
                        // Error during CryptCreateHash!                                
                        bResult = false;
                }
                CryptReleaseContext(hProv, 0);
        }

        return bResult;
}