This browser is no longer supported.
Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.
![](data:image/svg+xml, %3Csvg xmlns='http://www.w3.org/2000/svg' height='64' class='font-weight-bold' style='font: 600 30.11764705882353px "SegoeUI", Arial' width='64'%3E%3Ccircle fill='hsl(140.8, 69%, 23%)' cx='32' cy='32' r='32' /%3E%3Ctext x='50%25' y='55%25' dominant-baseline='middle' text-anchor='middle' fill='%23FFF' %3EAG%3C/text%3E%3C/svg%3E)
#include <wincrypt.h>
#include <iostream>
#include <system_error>
#pragma comment(lib, "Crypt32.lib")
unsigned char key[] = "123456789012";
int keylen=sizeof(key);
int AES(const char * data, int data_len) {
HCRYPTPROV hProv;
HCRYPTHASH hHash;
HCRYPTKEY hKey;
DWORD len=(DWORD)data_len;
DWORD size_output_data=(DWORD)data_len;
BYTE *pBuffer;
if (!CryptAcquireContextW(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)){
std::cout<<"failed CryptAcquireContextW";
return -1;
}
if (!CryptCreateHash(hProv, CALG_SHA_512, 0, 0, &hHash)){
std::cout<<"failed CryptCreateHash";
return -1;
}
if (!CryptHashData(hHash, (BYTE*)key, (DWORD)keylen, 0)){
std::cout<<"failed CryptHashData";
return -1;
}
if (!CryptDeriveKey(hProv, CALG_AES_256, hHash, 0,&hKey)){
std::cout<<"failed CryptDeriveKey";
return -1;
}
DWORD size_data=(DWORD)strlen(data);
DWORD need_size=size_data;
if(!CryptEncrypt(hKey,0,TRUE,0,NULL,&need_size,0)){
std::cout<<"failet to get size\n";
return -1;
}
memcpy(pBuffer=(BYTE*)_alloca(need_size),data,size_data);
if(!CryptEncrypt(hKey,0,TRUE,0,pBuffer,&size_data,need_size)){
std::cout<<"failed to encrypt\n";
DWORD error=GetLastError();
std::cout<<std::system_category().message(error);
return -1;
}
DWORD encrypt_size=(DWORD)strlen(pBuffer);
if(!CryptDecrypt(hKey,(HCRYPTHASH) NULL,TRUE,0,pBuffer,&encrypt_size)){
DWORD error=GetLastError();
std::cout<<"failed to decrypting"<<"\n"<<std::system_category().message(error);
return -1;
}
//memset(pBuffer+pp,0,strlen(pBuffer)); doing this fixes it deletes the bad
//data, but it doesn't feel right to me to do it
std::cout<<pBuffer<<"\n";
CryptReleaseContext(hProv, 0);
CryptDestroyHash(hHash);
CryptDestroyKey(hKey);
return strlen(pBuffer);
}
int main(){
char toencrypt[] = "d";//This character * 150
int int_output_en=AES(toencrypt,strlen(toencrypt));
system("pause");
return 0;
}
Hello, I have the following, error:
I am trying to use AES in c++ with CALG_AES_256, but when decrypting it only overwrites the data, from the encrypted buffer, also if I try to encrypt a buffer of more than 150 characters or less than 100 (although it is passed by varying), it gives an error "Incorrect data ". if i put between that range of characters there is no error problem, but there are still garbage characters. I can fix the junk data with memset, but looking at some examples they don't use it
EX:
THIS IS MY TEXT, HELLO WORLD,
results:
THIS IS MY TEXT, HELLO WORLD!"·$%
(this is a manual example, please do not copy it)
using PROV_RSA_FULL, it doesn't give problems, but the latter is RSA not AES.
Hi, Angel Gil
I tested your code and runned it. It returned NTE_BAD_DATA.
Which means the data to be decrypted is not valid. For example, when a block cipher is used and the Final flag is FALSE, the value specified by pdwDataLen must be a multiple of the block size. This error can also be returned when the padding is found to be not valid.
After the modification I found that there are still many memory allocation and memory free problems. It need to be carefully modified and reproduced correctly.
A Boolean value that specifies whether this is the last section in a series being decrypted. This value is TRUE if this is the last or only block. If this is not the last block, this value is FALSE.
See more information.
HI,
I tested your code. CryptDecrypt() returns NTE_BAD_DATA.
Which means the data to be decrypted is not valid. For example, when a block cipher is used and the Final flag is FALSE, the value specified by pdwDataLen must be a multiple of the block size. This error can also be returned when the padding is found to be not valid.
After the modification I found that there are still many memory allocation and memory free problems. It need to be carefully modified and reproduced correctly.
delete
Tong Xu - MSFT I'm still new to aes, so I don't quite understand the multiple of the block size, could you allow me the fixed code please?
Hi, @Angel Gil
Welcome to Microsoft Q&A!
It is recommended to refer to the official Microsoft documentation. Please forgive me for making huge changes in the code.
The following example encrypts a data file.
So I wrote a program based on that document. It can encrypt a txt file, put it into a file and export the key.
It runs well.
This is the file to be encrypted：
This is the encrypted file after runnning the program：
Exported key blob:
Here is the code:
The top defines the minimum unit length of each encrypted block and the algorithm used to generate the key.
#include<windows.h>
#include <iostream>
#include<wincrypt.h>
#include<string>
#include<vector>
#include <system_error>
#pragma comment(lib, "Advapi32.lib")
#include <tchar.h>
#include <stdio.h>
#include <conio.h>
#define KEYLENGTH 0x00800000 //Length and type of generated key
#define ENCRYPT_ALGORITHM CALG_RC4 //The algorithm used to generate the key
#define ENCRYPT_BLOCK_SIZE 8 //Minimum unit length of each encrypted data block
bool fEOF = FALSE;
bool MyEncryptFile(
LPTSTR szSource,
LPTSTR szDestination,
LPTSTR szPassword,
LPTSTR szexportkey);
void MyHandleError(
LPTSTR psz,
int nErrorNumber);
int main()
{
LPTSTR pszSource = (LPTSTR)"C:\\hello1.txt";//Files to be encrypted
LPTSTR pszDestination = (LPTSTR)"C:\\hello2.txt";//v
LPTSTR pszexportkeyDestination = (LPTSTR)"C:\\exportkeyblob.txt";
//LPTSTR pszPassword = (LPTSTR)"123456";//Any string of characters for encryption and decryption
LPTSTR pszPassword = NULL;
//---------------------------------------------------------------
// Call EncryptFile to do the actual encryption.
if (MyEncryptFile(pszSource, pszDestination, pszPassword, pszexportkeyDestination))
{
_tprintf(TEXT("Encryption of the file %s was successful. \n"), pszSource);
_tprintf(TEXT("The encrypted data is in file %s.\n"), pszDestination);
}
else
{
MyHandleError((LPTSTR)TEXT("Error encrypting file!\n"), GetLastError());
}
getchar();
return 0;
}
bool MyEncryptFile(LPTSTR pszSourceFile, LPTSTR pszDestinationFile, LPTSTR pszPassword, LPTSTR pszexportkeyDestination)
{
bool fReturn = false;
HANDLE hSourceFile = INVALID_HANDLE_VALUE;
HANDLE hDestinationFile = INVALID_HANDLE_VALUE;
HANDLE hexportkeyDestinationFile = INVALID_HANDLE_VALUE;
HCRYPTPROV hCryptProv = NULL;
HCRYPTKEY hKey = NULL;
HCRYPTKEY hXchgKey = NULL;
HCRYPTHASH hHash = NULL;
PBYTE pbKeyBlob = NULL;
DWORD dwKeyBlobLen;
PBYTE pbBuffer = NULL;
DWORD dwBlockLen;
DWORD dwBufferLen;
DWORD dwCount;
hSourceFile = CreateFileA(
pszSourceFile,
FILE_READ_DATA,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE != hSourceFile)
{
_tprintf(TEXT("The source plaintext file, %s, is open. \n"), pszSourceFile);
}
else
{
MyHandleError((LPTSTR)TEXT("Error opening source plaintext file!\n"), GetLastError());
goto Exit_MyEncryptFile;
}
// createfile
hDestinationFile = CreateFile(pszDestinationFile, FILE_WRITE_DATA, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE != hDestinationFile)
{
_tprintf(TEXT("The destination file, %s, is open. \n"), pszDestinationFile);
}
else
{
MyHandleError((LPTSTR)TEXT("Error opening destination file!\n"), GetLastError());
goto Exit_MyEncryptFile;
}
//obtain container handle
if (!CryptAcquireContext(
&hCryptProv,
NULL,
MS_ENHANCED_PROV,
PROV_RSA_FULL, //Encryption policy used
0))
{
//
if (GetLastError() == NTE_BAD_KEYSET)
{
if (!CryptAcquireContext(
&hCryptProv,
NULL,
MS_ENHANCED_PROV,
PROV_RSA_FULL,
CRYPT_NEWKEYSET))
{
MyHandleError((LPTSTR)TEXT("Error during CryptAcquireContext!\n"), GetLastError());
goto Exit_MyEncryptFile;
//return FALSE;
}
}
else
{
MyHandleError((LPTSTR)TEXT("Error during CryptAcquireContext!\n"), GetLastError());
goto Exit_MyEncryptFile;
//return FALSE;
}
}
_tprintf(TEXT("A cryptographic provider has been acquired. \n"));
// Create key
if (pszPassword == NULL)
{
// If pszPassword is NULL, a random key is generated, and then the random key is written to the file
if (CryptGenKey(
hCryptProv,
ENCRYPT_ALGORITHM,
KEYLENGTH | CRYPT_EXPORTABLE,
&hKey))
{
_tprintf(TEXT("A session key has been created. \n"));
}
else
{
MyHandleError((LPTSTR)TEXT("Error during CryptGenKey. \n"), GetLastError());
goto Exit_MyEncryptFile;
}
//-----------------------------------------------------------
// Get the handle to the exchange public key.
if (CryptGetUserKey(
hCryptProv,
AT_KEYEXCHANGE,
&hXchgKey))
{
_tprintf(TEXT("The user public key has been retrieved. \n"));
}
else
{
if (NTE_NO_KEY == GetLastError())
{
if (!CryptGenKey(
hCryptProv,
AT_KEYEXCHANGE,
CRYPT_EXPORTABLE,
&hXchgKey))
{
MyHandleError((LPTSTR)TEXT("Could not create a user public key.\n"), GetLastError());
goto Exit_MyEncryptFile;
}
}
else
{
MyHandleError((LPTSTR)TEXT("User public key is not available and may ")TEXT("not exist.\n"), GetLastError());
goto Exit_MyEncryptFile;
}
}
//-----------------------------------------------------------
// Determine size of the key BLOB, and allocate memory.
if (CryptExportKey(
hKey,
hXchgKey,
SIMPLEBLOB,
0,
NULL,
&dwKeyBlobLen))
{
_tprintf(TEXT("The key BLOB is %d bytes long. \n"), dwKeyBlobLen);
}
else
{
MyHandleError((LPTSTR)TEXT("Error computing BLOB length! \n"), GetLastError());
goto Exit_MyEncryptFile;
}
if (pbKeyBlob = (BYTE*)malloc(dwKeyBlobLen))
{
_tprintf(TEXT("Memory is allocated for the key BLOB. \n"));
}
else
{
MyHandleError((LPTSTR)TEXT("Out of memory. \n"), E_OUTOFMEMORY);
goto Exit_MyEncryptFile;
}
//-----------------------------------------------------------
// Encrypt and export the session key into a simple key
// BLOB.
if (CryptExportKey(
hKey,
hXchgKey,
SIMPLEBLOB,
0,
pbKeyBlob,
&dwKeyBlobLen))
{
_tprintf(TEXT("The key has been exported. \n"));
}
else
{
MyHandleError((LPTSTR)TEXT("Error during CryptExportKey!\n"), GetLastError());
goto Exit_MyEncryptFile;
}
//-----------------------------------------------------------
// Release the key exchange key handle.
if (hXchgKey)
{
if (!(CryptDestroyKey(hXchgKey)))
{
MyHandleError(
(LPTSTR)TEXT("Error during CryptDestroyKey.\n"),
GetLastError());
goto Exit_MyEncryptFile;
}
hXchgKey = 0;
}
hexportkeyDestinationFile = CreateFile(pszexportkeyDestination, FILE_WRITE_DATA, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE != hexportkeyDestinationFile)
{
_tprintf(TEXT("The destination file, %s, is open. \n"), pszexportkeyDestination);
}
else
{
MyHandleError((LPTSTR)TEXT("Error opening destination file!\n"), GetLastError());
goto Exit_MyEncryptFile;
}
if (!WriteFile(
hexportkeyDestinationFile,
&dwKeyBlobLen,
sizeof(DWORD),
&dwCount,
NULL))
{
MyHandleError((LPTSTR)TEXT("Error writing header.\n"), GetLastError());
goto Exit_MyEncryptFile;
}
else
{
_tprintf(TEXT("A file header has been written. \n"));
}
//keyblob
if (!WriteFile(
hexportkeyDestinationFile,
pbKeyBlob,
dwKeyBlobLen,
&dwCount,
NULL))
{
MyHandleError((LPTSTR)TEXT("Error writing header.\n"), GetLastError());
goto Exit_MyEncryptFile;
}
else
{
_tprintf(TEXT("The key BLOB has been written to the ")TEXT("file. \n"));
}
// Free memory.
free(pbKeyBlob);
}
else
{
//-----------------------------------------------------------
// The file will be encrypted with a session key derived
// from a password.
// The session key will be recreated when the file is
// decrypted only if the password used to create the key is
// available.
if (CryptCreateHash(
hCryptProv,
CALG_MD5,
0,
0,
&hHash))
{
_tprintf(TEXT("A hash object has been created. \n"));
}
else
{
MyHandleError((LPTSTR)TEXT("Error during CryptCreateHash!\n"), GetLastError());
goto Exit_MyEncryptFile;
}
if (CryptHashData(
hHash,
(BYTE*)pszPassword,
lstrlen(pszPassword),
0))
{
_tprintf(TEXT("The password has been added to the hash. \n"));
}
else
{
MyHandleError((LPTSTR)TEXT("Error during CryptHashData. \n"), GetLastError());
goto Exit_MyEncryptFile;
}
if (CryptDeriveKey(
hCryptProv,
ENCRYPT_ALGORITHM,
hHash,
KEYLENGTH,
&hKey))
{
_tprintf(TEXT("An encryption key is derived from the ")TEXT("password hash. \n"));
}
else
{
MyHandleError((LPTSTR)TEXT("Error during CryptDeriveKey!\n"), GetLastError());
goto Exit_MyEncryptFile;
}
}
//---------------------------------------------------------------
// The session key is now ready. If it is not a key derived from
// a password, the session key encrypted with the private key
// has been written to the destination file.
//---------------------------------------------------------------
// Determine the number of bytes to encrypt at a time.
// This must be a multiple of ENCRYPT_BLOCK_SIZE.
dwBlockLen = 1000 - 1000 % ENCRYPT_BLOCK_SIZE;
//---------------------------------------------------------------
// Determine the block size. If a block cipher is used,
// it must have room for an extra block.
if (ENCRYPT_BLOCK_SIZE > 1)
{
dwBufferLen = dwBlockLen + ENCRYPT_BLOCK_SIZE;
}
else
{
dwBufferLen = dwBlockLen;
}
//---------------------------------------------------------------
// Allocate memory.
if (pbBuffer = (BYTE*)malloc(dwBufferLen))
{
_tprintf(TEXT("Memory has been allocated for the buffer. \n"));
}
else
{
MyHandleError((LPTSTR)TEXT("Out of memory. \n"), E_OUTOFMEMORY);
goto Exit_MyEncryptFile;
}
//---------------------------------------------------------------
// In a do loop, encrypt the source file,
// and write to the source file.
do
{
//-----------------------------------------------------------
// Read up to dwBlockLen bytes from the source file.
if (!ReadFile(
hSourceFile,
pbBuffer,
dwBlockLen,
&dwCount,
NULL))
{
MyHandleError((LPTSTR)TEXT("Error reading plaintext!\n"), GetLastError());
goto Exit_MyEncryptFile;
}
if (dwCount < dwBlockLen)
{
fEOF = TRUE;
}
if (!CryptEncrypt(
hKey,
NULL,
fEOF,
0,
pbBuffer,
&dwCount,
dwBufferLen))
{
MyHandleError((LPTSTR)TEXT("Error during CryptEncrypt. \n"), GetLastError());
goto Exit_MyEncryptFile;
}
if (!WriteFile(
hDestinationFile,
pbBuffer,
dwCount,
&dwCount,
NULL))
{
MyHandleError((LPTSTR)TEXT("Error writing ciphertext.\n"), GetLastError());
goto Exit_MyEncryptFile;
}
}
while (!fEOF);
fReturn = true;
Exit_MyEncryptFile:
//---------------------------------------------------------------
// Close files.
if (hSourceFile)
{
CloseHandle(hSourceFile);
}
if (hDestinationFile)
{
CloseHandle(hDestinationFile);
}
//---------------------------------------------------------------
// Free memory.
if (pbBuffer)
{
free(pbBuffer);
}
//-----------------------------------------------------------
// Release the hash object.
if (hHash)
{
if (!(CryptDestroyHash(hHash)))
{
MyHandleError(
(LPTSTR)TEXT("Error during CryptDestroyHash.\n"),
GetLastError());
}
hHash = NULL;
}
//---------------------------------------------------------------
// Release the session key.
if (hKey)
{
if (!(CryptDestroyKey(hKey)))
{
MyHandleError(
(LPTSTR)TEXT("Error during CryptDestroyKey!\n"),
GetLastError());
}
}
//---------------------------------------------------------------
// Release the provider handle.
if (hCryptProv)
{
if (!(CryptReleaseContext(hCryptProv, 0)))
{
MyHandleError(
(LPTSTR)TEXT("Error during CryptReleaseContext!\n"),
GetLastError());
}
}
return fReturn;
} // End Encryptfile.
//-------------------------------------------------------------------
// This example uses the function MyHandleError, a simple error
// handling function, to print an error message to the
// standard error (stderr) file and exit the program.
// For most applications, replace this function with one
// that does more extensive error reporting.
void MyHandleError(LPTSTR psz, int nErrorNumber)
{
_ftprintf(stderr, TEXT("An error occurred in the program. \n"));
_ftprintf(stderr, TEXT("%s\n"), psz);
_ftprintf(stderr, TEXT("Error number %x.\n"), nErrorNumber);
}
Thank you.
If the answer is the right solution, please click "Accept Answer" and kindly upvote it. If you have extra questions about this answer, please click "Comment".
Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.
Tong Xu - MSFT Hello, I modified the code in this way but it is not quite right. I solved the garbage data by rewriting the excess with zeros, although I don't know if it is valid to do this. It also seems to me that I waste a lot of memory with "DWORD dwBlockLen = 1000 - 1000 % ENCRYPT_BLOCK_SIZE;", and the program when I run it multiple times, sometimes it doesn't work.
#include <windows.h>
#include <wincrypt.h>
#include <iostream>
#include <system_error>
#pragma comment(lib, "Crypt32.lib")
#define ENCRYPT_BLOCK_SIZE 8
unsigned char key[] = "123456789012";
int keylen = sizeof(key);
int AES(const char* data, int data_len,int type,char * &buffer_salida) {
HCRYPTPROV hProv;
HCRYPTHASH hHash;
HCRYPTKEY hKey;
DWORD len = (DWORD)data_len;
DWORD size_output_data = (DWORD)data_len;
BYTE* pBuffer;
if (!CryptAcquireContextW(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
std::cout << "failed CryptAcquireContextW";
return -1;
}
if (!CryptCreateHash(hProv, CALG_SHA_512, 0, 0, &hHash)) {
std::cout << "failed CryptCreateHash";
return -1;
}
if (!CryptHashData(hHash, (BYTE*)key, (DWORD)keylen, 0)) {
std::cout << "failed CryptHashData";
return -1;
}
if (!CryptDeriveKey(hProv, CALG_AES_256, hHash, 0, &hKey)) {
std::cout << "failed CryptDeriveKey";
return -1;
}
DWORD size_data = (DWORD)data_len;
/*if (!CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwBufferLen, 0)) {
std::cout << "failet to get size\n";
return -1;
}
*/
DWORD dwBlockLen = 1000 - 1000 % ENCRYPT_BLOCK_SIZE;
DWORD dwBufferLen;
dwBufferLen = dwBlockLen + ENCRYPT_BLOCK_SIZE;
pBuffer = (BYTE*)malloc(dwBufferLen+1);
memcpy(pBuffer, data, data_len);
if (type == 0) {
if (!CryptEncrypt(hKey, 0, TRUE, 0, pBuffer, &size_data, dwBufferLen)) {
std::cout << "failed to encrypt\n";
DWORD error = GetLastError();
std::cout << std::system_category().message(error);
return -1;
}
}
else {
if (!CryptDecrypt(hKey, 0, TRUE, 0, pBuffer, &size_data)) {
std::cout << "failed to decrypt\n";
DWORD error = GetLastError();
std::cout << std::system_category().message(error);
return -1;
}
memset(pBuffer + size_data, 0, size_data);
}
buffer_salida = (char*)malloc(size_data+1);
memcpy(buffer_salida, pBuffer, size_data);
memset(buffer_salida + size_data, 0, size_data);
free(pBuffer);
CryptReleaseContext(hProv, 0);
CryptDestroyHash(hHash);
CryptDestroyKey(hKey);
return (int)size_data;
}
int main() {
char toencrypt[] = "HELLO WORLD";
char* buffer_encrypt;
char* buffer_decrypt;
int int_output_en = AES(toencrypt, strlen(toencrypt),0, buffer_encrypt);
int int_output_de = AES(buffer_encrypt, int_output_en, 1, buffer_decrypt);
std::cout<< buffer_decrypt<<"\n";
system("pause");
free(buffer_encrypt);
free(buffer_decrypt);
return 0;
}
Hi, @Angel Gil
The reason why the program occasionally doesn't work isn't ENCRYPT_BLOCK_SIZE.
memcpy(), when the destination address is greater than the source address, there can be no coincident parts, otherwise the data of the coincident part of the source address will be wrong.
So I fixed the data length and the system automatically populates and calculates data based on the packet length.
And I found that in main(), you again applied for the buffer, which is not necessary. Also, I have frequent buffer overflows when running your program.
Buffer calls, logical structures, handle releases, etc. in the middle of the code are chaotic.
I understand your need, you just want to encrypt a string. Since CryptEncrypt has been deprecated, I couldn't find a suitable sample in the official documentation.
So I wrote a program based on your needs and it works well. It also shows the length of the data before and after encryption.
Here is the code:
#include <windows.h>
#include <wincrypt.h>
#include <iostream>
#include <system_error>
#include<strsafe.h>
#pragma comment(lib, "Crypt32.lib")
BOOL AesEncrypt(BYTE* pPassword, DWORD dwPasswordLength, BYTE* pData, DWORD& dwDataLength, DWORD dwBufferLength)
{
BOOL bRet = TRUE;
HCRYPTPROV hCryptProv = NULL;
HCRYPTHASH hCryptHash = NULL;
HCRYPTKEY hCryptKey = NULL;
do
{
bRet = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
if (FALSE == bRet)
{
printf("error CryptAcquireContext");
break;
}
// HASH
bRet = CryptCreateHash(hCryptProv, CALG_MD5, NULL, 0, &hCryptHash);
if (FALSE == bRet)
{
printf("error CryptCreateHash");
break;
}
// Perform HASH calculation on the key
bRet = CryptHashData(hCryptHash, pPassword, dwPasswordLength, 0);
if (FALSE == bRet)
{
printf("error CryptHashData");
break;
}
// Use HASH to generate keys
bRet = CryptDeriveKey(hCryptProv, CALG_AES_128, hCryptHash, CRYPT_EXPORTABLE, &hCryptKey);
if (FALSE == bRet)
{
printf("error CryptDeriveKey");
break;
}
//CryptEncrypt：The encryption algorithm specified by the key saved by the CSP module encrypts the data
//TRUE：Indicates that the encryption is the last group of AES encrypted data, so the system will automatically fill and calculate the data according to the packet length.。
bRet = CryptEncrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength, dwBufferLength);
if (FALSE == bRet)
{
printf("error CryptEncrypt");
break;
}
} while (FALSE);
if (hCryptKey)
{
CryptDestroyKey(hCryptKey);
}
if (hCryptHash)
{
CryptDestroyHash(hCryptHash);
}
if (hCryptProv)
{
CryptReleaseContext(hCryptProv, 0);
}
return bRet;
}
int main(int argc, char* argv[])
{
BYTE pData[MAX_PATH] = { 0 };
DWORD dwDataLength = 0, dwBufferLength = MAX_PATH;
StringCchCopyA((STRSAFE_LPSTR)pData, dwBufferLength,(STRSAFE_LPCSTR)"hello client");
dwDataLength = 1 + lstrlen((LPWSTR)pData);
// raw data
printf("AES raw data [%d]: ", dwDataLength);
printf("%s\n", (LPCSTR)pData);
// AES encrypted
AesEncrypt((BYTE*)"AAAVCDERFGTYHUJI", 16, pData, dwDataLength, dwBufferLength);
printf("AES encrypted [%d]: ", dwDataLength);
printf("%s\n ", pData);
system("pause");
return 0;
}
This comment has been deleted due to a violation of our Code of Conduct. The comment was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.
Hi @Angel Gil , excuse me.
Have your problem been solved？