OPENSSL ошибка "digital envelope routines:EVP_DecryptFinal_ex:wrong final block length:crypto\evp\ev"

// AES_EVP.cpp: реализация CAES_EVP
 
#pragma comment(lib, "IPHLPAPI.lib")
#include <winsock2.h>
#include <iphlpapi.h>
#include <algorithm> 
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <memory>
#include <stdexcept>
#include <array>
#include <tchar.h>
#define _WIN32_DCOM
#include <comdef.h>
#include <Wbemidl.h>
#include <chrono>
#include <ctime>
#include <fstream>
#include <stdio.h>  /* defines FILENAME_MAX */
#include <direct.h>
#include <string.h>
#include <iostream>
#include "base64.h"
#include <atlconv.h>
#include <atlbase.h>
#include <atlconv.h>
#include <assert.h> 
#include <openssl/conf.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include <openssl/applink.c>
// CAES_EVP
 
#define GetCurrentDir _getcwd
#define INFO_BUFFER_SIZE 32767
#pragma comment(lib, "wbemuuid.lib")
using namespace std;
 
#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
 
template<typename T>
 
static std::string HexToString(T uval)
{
    std::stringstream ss;
    ss << std::setw(sizeof(uval) * 2) << std::setfill('0') << std::hex << +uval;
    std::string strToConvert = ss.str();
    std::transform(strToConvert.begin(), strToConvert.end(), strToConvert.begin(), ::toupper);
    return strToConvert;
}
 
std::wstring GetMac()
{
    std::wstring result;
    unsigned int i = 0;
    DWORD dwRetVal = 0;
    ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
    ULONG family = AF_INET;
    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
    ULONG outBufLen = sizeof(IP_ADAPTER_ADDRESSES);
    pAddresses = (IP_ADAPTER_ADDRESSES *)MALLOC(outBufLen);
 
    if (GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen) == ERROR_BUFFER_OVERFLOW)
    {
        FREE(pAddresses);
        pAddresses = (IP_ADAPTER_ADDRESSES *)MALLOC(outBufLen);
    }
 
    if (pAddresses == NULL)
        return L"";
 
    dwRetVal = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
    if (dwRetVal == NO_ERROR)
    {
        if (pAddresses->PhysicalAddressLength != 0)
        {
            std::string str;
            for (i = 0; i < pAddresses->PhysicalAddressLength; i++)
            {
                if (i == (pAddresses->PhysicalAddressLength - 1))
                    str += HexToString((unsigned char)pAddresses->PhysicalAddress[i]);
                else
                    str += HexToString((unsigned char)pAddresses->PhysicalAddress[i]) + ":";
            }
            result = std::wstring(str.begin(), str.end());
        }
    }
    FREE(pAddresses);
    return result;
}
 
std::string getFirstHddSerialNumber() {
    //get a handle to the first physical drive
    HANDLE h = CreateFileW(L"\\\\.\\PhysicalDrive0", 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
    if (h == INVALID_HANDLE_VALUE) return{};
    //an std::unique_ptr is used to perform cleanup automatically when returning (i.e. to avoid code duplication)
    std::unique_ptr<std::remove_pointer<HANDLE>::type, void(*)(HANDLE)> hDevice{ h, [](HANDLE handle) {CloseHandle(handle); } };
    //initialize a STORAGE_PROPERTY_QUERY data structure (to be used as input to DeviceIoControl)
    STORAGE_PROPERTY_QUERY storagePropertyQuery{};
    storagePropertyQuery.PropertyId = StorageDeviceProperty;
    storagePropertyQuery.QueryType = PropertyStandardQuery;
    //initialize a STORAGE_DESCRIPTOR_HEADER data structure (to be used as output from DeviceIoControl)
    STORAGE_DESCRIPTOR_HEADER storageDescriptorHeader{};
    //the next call to DeviceIoControl retrieves necessary size (in order to allocate a suitable buffer)
    //call DeviceIoControl and return an empty std::string on failure
    DWORD dwBytesReturned = 0;
    if (!DeviceIoControl(hDevice.get(), IOCTL_STORAGE_QUERY_PROPERTY, &storagePropertyQuery, sizeof(STORAGE_PROPERTY_QUERY),
        &storageDescriptorHeader, sizeof(STORAGE_DESCRIPTOR_HEADER), &dwBytesReturned, NULL))
        return{};
    //allocate a suitable buffer
    const DWORD dwOutBufferSize = storageDescriptorHeader.Size;
    std::unique_ptr<BYTE[]> pOutBuffer{ new BYTE[dwOutBufferSize]{} };
    //call DeviceIoControl with the allocated buffer
    if (!DeviceIoControl(hDevice.get(), IOCTL_STORAGE_QUERY_PROPERTY, &storagePropertyQuery, sizeof(STORAGE_PROPERTY_QUERY),
        pOutBuffer.get(), dwOutBufferSize, &dwBytesReturned, NULL))
        return{};
    //read and return the serial number out of the output buffer
    STORAGE_DEVICE_DESCRIPTOR* pDeviceDescriptor = reinterpret_cast<STORAGE_DEVICE_DESCRIPTOR*>(pOutBuffer.get());
    const DWORD dwSerialNumberOffset = pDeviceDescriptor->SerialNumberOffset;
    if (dwSerialNumberOffset == 0) return{};
    const char* serialNumber = reinterpret_cast<const char*>(pOutBuffer.get() + dwSerialNumberOffset);
    return serialNumber;
}
 
void handleErrors(void)
{
    ERR_print_errors_fp(stderr);
    abort();
}
 
int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
    unsigned char *iv, unsigned char *ciphertext)
{
    EVP_CIPHER_CTX *ctx;
 
    int len;
 
    int ciphertext_len;
 
    /* Create and initialise the context */
    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
 
    /* Initialise the encryption operation. IMPORTANT - ensure you use a key
    * and IV size appropriate for your cipher
    * In this example we are using 256 bit AES (i.e. a 256 bit key). The
    * IV size for *most* modes is the same as the block size. For AES this
    * is 128 bits */
    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
        handleErrors();
 
    /* Provide the message to be encrypted, and obtain the encrypted output.
    * EVP_EncryptUpdate can be called multiple times if necessary
    */
    if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
        handleErrors();
    ciphertext_len = len;
 
    /* Finalise the encryption. Further ciphertext bytes may be written at
    * this stage.
    */
    if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();
    ciphertext_len += len;
 
    /* Clean up */
    EVP_CIPHER_CTX_free(ctx);
 
    return ciphertext_len;
}
 
int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
    unsigned char *iv, unsigned char *plaintext)
{
    EVP_CIPHER_CTX *ctx;
 
    int len;
 
    int plaintext_len;
 
    /* Create and initialise the context */
    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
 
    /* Initialise the decryption operation. IMPORTANT - ensure you use a key
    * and IV size appropriate for your cipher
    * In this example we are using 256 bit AES (i.e. a 256 bit key). The
    * IV size for *most* modes is the same as the block size. For AES this
    * is 128 bits */
    if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
        handleErrors();
 
    /* Provide the message to be decrypted, and obtain the plaintext output.
    * EVP_DecryptUpdate can be called multiple times if necessary
    */
    if (1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
        handleErrors();
    plaintext_len = len;
 
    /* Finalise the decryption. Further plaintext bytes may be written at
    * this stage.
    */
    if (1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors();
    plaintext_len += len;
 
    /* Clean up */
    EVP_CIPHER_CTX_free(ctx);
 
    return plaintext_len;
}
 
char* getchar_from_bstr(BSTR in) {
    int leng = wcslen(in);
    char * string = new char[leng + 1];
    int last = WideCharToMultiByte(CP_ACP, 0, in, leng, string, leng, 0, 0);
    string[last] = 0;
    return string;
}
 
string bstr_to_str(BSTR source) {
    //source = L"lol2inside";
    _bstr_t wrapped_bstr = _bstr_t(source);
    int length = wrapped_bstr.length();
    char* char_array = new char[length];
    strcpy_s(char_array, length + 1, wrapped_bstr);
    return char_array;
}
 
unsigned char* bstr_char(BSTR in) {
    int bstrLen = SysStringLen(in) + 1;
    int len = WideCharToMultiByte(CP_ACP, 0, in, bstrLen, NULL, 0,
        NULL, NULL);
    unsigned char * pBuffer = new unsigned char[len];
    WideCharToMultiByte(CP_ACP, 0, in, bstrLen, LPSTR(pBuffer), len,
        NULL, NULL);
    return pBuffer;
}
 
unsigned char* bstr_char_2(BSTR in) {
    int leng = wcslen(in);
    char * string = new char[leng + 1];
    int last = WideCharToMultiByte(CP_ACP, 0, in, leng, string, leng, 0, 0);
    string[last] = 0;
    return (unsigned char*)string;
}
 
BSTR char_bstr(unsigned char* in) {
    char * ansistr = (char *)in;
    int a = lstrlenA(ansistr);
    BSTR unicodestr = SysAllocStringLen(NULL, a);
    ::MultiByteToWideChar(CP_ACP, 0, ansistr, a, unicodestr, a);
    return unicodestr;
}
 
BSTR ENCRYPT(BSTR in, BSTR key) {
    unsigned char * pBuffer = bstr_char(in);
 
    unsigned char * key_v = bstr_char(key);
 
    unsigned char *key_ = (unsigned char*)"857759686370038057";
 
    char *temp = (char *)malloc(strlen((char*)key_v) + strlen((char*)key_) + 1);
    strcpy(temp, (char*)key_);
    strcat(temp, (char*)key_v);
 
    unsigned char *iv = (unsigned char*)"2371904392800624";//(unsigned char*)"199618872547325";
 
    unsigned char ciphertext[5000];
 
    int ciphertext_len;
 
    ciphertext_len = encrypt(pBuffer, strlen((char *)pBuffer), (unsigned char*)temp, iv, ciphertext);
 
    ciphertext[ciphertext_len] = '\0';
 
    std::string encoded = base64_encode(ciphertext, strlen((char *)ciphertext));
 
    ULONG ulSize = strlen((char*)reinterpret_cast<const unsigned char*>(encoded.c_str())) + sizeof(char);
    char* pszReturn = NULL;
 
    pszReturn = (char*)::CoTaskMemAlloc(ulSize);
    strcpy(pszReturn, (char*)(char*)reinterpret_cast<const unsigned char*>(encoded.c_str()));
    BSTR out = SysAllocString(CA2W(pszReturn));
 
    pBuffer = NULL;
    key_v = NULL;
    key_ = NULL;
    temp = NULL;
    iv = NULL;
    return out;
}
 
BSTR DECRYPT(BSTR in, BSTR key) {
    unsigned char * pBuffer = bstr_char(in);
 
    unsigned char * key_v = bstr_char(key);
 
    unsigned char *key_ = (unsigned char*)"857759686370038057";
 
    char *temp = (char *)malloc(strlen((char*)key_v) + strlen((char*)key_) + 1);
    strcpy(temp, (char*)key_);
    strcat(temp, (char*)key_v);
 
    unsigned char *iv = (unsigned char*)"2371904392800624";// (unsigned char*)"199618872547325";;
    unsigned char decryptedtext[5000];
 
    int decryptedtext_len;
 
    std::string sName(reinterpret_cast<char*>(pBuffer));
    std::string decoded = base64_decode(sName);
 
    /* _DECRYPT_AES_ the ciphertext */
    decryptedtext_len = decrypt((unsigned char*)reinterpret_cast<const unsigned char*>(decoded.c_str()),
        strlen((char *)(char*)reinterpret_cast<const unsigned char*>(decoded.c_str())), (unsigned char*)temp, iv,
        decryptedtext);
 
    /* Add a NULL terminator. We are expecting printable text */
    decryptedtext[decryptedtext_len] = '\0';
 
    ULONG ulSize = strlen((char*)decryptedtext) + sizeof(char);
    char* pszReturn = NULL;
 
    pszReturn = (char*)::CoTaskMemAlloc(ulSize);
 
    strcpy(pszReturn, (char*)decryptedtext);
 
    BSTR out = SysAllocString(CA2W(pszReturn));
 
    pBuffer = NULL;
    key_v = NULL;
    key_ = NULL;
    temp = NULL;
    iv = NULL;
    return out;
}
 
BSTR GET_PARAM_()
{
    // TODO: добавьте код реализации
    time_t rawtime;
    struct tm * timeinfo;
    char buffer[15];
 
    time(&rawtime);
    timeinfo = localtime(&rawtime);
 
    strftime(buffer, sizeof(buffer), "%d%m%Y%H%M%S", timeinfo);
    BSTR GET_TIME = SysAllocString(CA2W(buffer));
    return GET_TIME;
}
 
 
void main()
{
    for (int i = 0; i < 100; i++) {
        BSTR KEY = GET_PARAM_();
        BSTR ENCR = ENCRYPT(SysAllocString(L"new string"), KEY);
        BSTR decr = DECRYPT(ENCR, KEY);
        wcout << ENCR << endl;
        wcout << decr << endl;
        cout << "----------------------------------" << endl;
    }
    system("pause");
}