winpr/libwinpr/crypto/crypto.c

 
#include <winpr/config.h>
 
#include <winpr/crypto.h>
 
#ifndef _WIN32
 
#include "crypto.h"
 
#include <winpr/crt.h>
#include <winpr/collections.h>
 
static wListDictionary* g_ProtectedMemoryBlocks = NULL;
 
BOOL CryptProtectMemory(LPVOID pData, DWORD cbData, DWORD dwFlags)
{
  BYTE* pCipherText = NULL;
  size_t cbOut = 0;
  size_t cbFinal = 0;
  WINPR_CIPHER_CTX* enc = NULL;
  BYTE randomKey[256] = { 0 };
  WINPR_PROTECTED_MEMORY_BLOCK* pMemBlock = NULL;
 
  if (dwFlags != CRYPTPROTECTMEMORY_SAME_PROCESS)
    return FALSE;
 
  if (!g_ProtectedMemoryBlocks)
  {
    g_ProtectedMemoryBlocks = ListDictionary_New(TRUE);
 
    if (!g_ProtectedMemoryBlocks)
      return FALSE;
  }
 
  pMemBlock = (WINPR_PROTECTED_MEMORY_BLOCK*)calloc(1, sizeof(WINPR_PROTECTED_MEMORY_BLOCK));
 
  if (!pMemBlock)
    return FALSE;
 
  pMemBlock->pData = pData;
  pMemBlock->cbData = cbData;
  pMemBlock->dwFlags = dwFlags;
 
  winpr_RAND(pMemBlock->salt, 8);
  winpr_RAND(randomKey, sizeof(randomKey));
 
  winpr_Cipher_BytesToKey(WINPR_CIPHER_AES_256_CBC, WINPR_MD_SHA1, pMemBlock->salt, randomKey,
                          sizeof(randomKey), 4, pMemBlock->key, pMemBlock->iv);
 
  SecureZeroMemory(randomKey, sizeof(randomKey));
 
  cbOut = pMemBlock->cbData + 16 - 1;
  pCipherText = (BYTE*)calloc(1, cbOut);
 
  if (!pCipherText)
    goto out;
 
  if ((enc = winpr_Cipher_NewEx(WINPR_CIPHER_AES_256_CBC, WINPR_ENCRYPT, pMemBlock->key,
                                sizeof(pMemBlock->key), pMemBlock->iv, sizeof(pMemBlock->iv))) ==
      NULL)
    goto out;
  if (!winpr_Cipher_Update(enc, pMemBlock->pData, pMemBlock->cbData, pCipherText, &cbOut))
    goto out;
  if (!winpr_Cipher_Final(enc, pCipherText + cbOut, &cbFinal))
    goto out;
  winpr_Cipher_Free(enc);
 
  CopyMemory(pMemBlock->pData, pCipherText, pMemBlock->cbData);
  free(pCipherText);
 
  return ListDictionary_Add(g_ProtectedMemoryBlocks, pData, pMemBlock);
out:
  free(pMemBlock);
  free(pCipherText);
  winpr_Cipher_Free(enc);
 
  return FALSE;
}
 
BOOL CryptUnprotectMemory(LPVOID pData, DWORD cbData, DWORD dwFlags)
{
  BYTE* pPlainText = NULL;
  size_t cbOut = 0;
  size_t cbFinal = 0;
  WINPR_CIPHER_CTX* dec = NULL;
  WINPR_PROTECTED_MEMORY_BLOCK* pMemBlock = NULL;
 
  if (dwFlags != CRYPTPROTECTMEMORY_SAME_PROCESS)
    return FALSE;
 
  if (!g_ProtectedMemoryBlocks)
    return FALSE;
 
  pMemBlock =
      (WINPR_PROTECTED_MEMORY_BLOCK*)ListDictionary_GetItemValue(g_ProtectedMemoryBlocks, pData);
 
  if (!pMemBlock)
    goto out;
 
  cbOut = pMemBlock->cbData + 16 - 1;
 
  pPlainText = (BYTE*)malloc(cbOut);
 
  if (!pPlainText)
    goto out;
 
  if ((dec = winpr_Cipher_NewEx(WINPR_CIPHER_AES_256_CBC, WINPR_DECRYPT, pMemBlock->key,
                                sizeof(pMemBlock->key), pMemBlock->iv, sizeof(pMemBlock->iv))) ==
      NULL)
    goto out;
  if (!winpr_Cipher_Update(dec, pMemBlock->pData, pMemBlock->cbData, pPlainText, &cbOut))
    goto out;
  if (!winpr_Cipher_Final(dec, pPlainText + cbOut, &cbFinal))
    goto out;
  winpr_Cipher_Free(dec);
 
  CopyMemory(pMemBlock->pData, pPlainText, pMemBlock->cbData);
  SecureZeroMemory(pPlainText, pMemBlock->cbData);
  free(pPlainText);
 
  ListDictionary_Remove(g_ProtectedMemoryBlocks, pData);
 
  free(pMemBlock);
 
  return TRUE;
 
out:
  free(pPlainText);
  free(pMemBlock);
  winpr_Cipher_Free(dec);
  return FALSE;
}
 
BOOL CryptProtectData(DATA_BLOB* pDataIn, LPCWSTR szDataDescr, DATA_BLOB* pOptionalEntropy,
                      PVOID pvReserved, CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct, DWORD dwFlags,
                      DATA_BLOB* pDataOut)
{
  return TRUE;
}
 
BOOL CryptUnprotectData(DATA_BLOB* pDataIn, LPWSTR* ppszDataDescr, DATA_BLOB* pOptionalEntropy,
                        PVOID pvReserved, CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct, DWORD dwFlags,
                        DATA_BLOB* pDataOut)
{
  return TRUE;
}
 
BOOL CryptStringToBinaryW(LPCWSTR pszString, DWORD cchString, DWORD dwFlags, BYTE* pbBinary,
                          DWORD* pcbBinary, DWORD* pdwSkip, DWORD* pdwFlags)
{
  return TRUE;
}
 
BOOL CryptStringToBinaryA(LPCSTR pszString, DWORD cchString, DWORD dwFlags, BYTE* pbBinary,
                          DWORD* pcbBinary, DWORD* pdwSkip, DWORD* pdwFlags)
{
  return TRUE;
}
 
BOOL CryptBinaryToStringW(CONST BYTE* pbBinary, DWORD cbBinary, DWORD dwFlags, LPWSTR pszString,
                          DWORD* pcchString)
{
  return TRUE;
}
 
BOOL CryptBinaryToStringA(CONST BYTE* pbBinary, DWORD cbBinary, DWORD dwFlags, LPSTR pszString,
                          DWORD* pcchString)
{
  return TRUE;
}
 
#endif