Преобразовать тип данных char[] -> wchar -> BYTE для структуры DATA_BLOB crypt32.dll

#pragma comment(lib, "crypt32.lib")
 
#include <windows.h>
#include <stdio.h>  // printf
#include <stdlib.h> // system
#include <Wincrypt.h>
 
//#define MY_ENCODING_TYPE  (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
 
void MyHandleError(char *s);
 
/*
typedef int (__cdecl *pCryptProtectData)(
            DATA_BLOB *pDataIn,
            LPCWSTR szDataDescr,
            DATA_BLOB *pOptionalEntropy,
            PVOID pvReserved,
            CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct,
            DWORD dwFlags,
            DATA_BLOB *pDataOut);
 */
 
int main(int argc, char *argv[])
{
    //if (argc < 2) exit(0); //using();
 
    // Declare and initialize variables.
 
    DATA_BLOB DataIn;
    DATA_BLOB DataOut;
    DATA_BLOB DataVerify;
    BYTE *pbDataInput =(BYTE*)"secret"; //  <---- Need UNICODE. Here we trying to encrypt the word "secret"
    //BYTE *pbDataInput =(BYTE*)argv[1];
    DWORD cbDataInput = strlen((char*)pbDataInput)+1;
    DataIn.pbData = pbDataInput;
    DataIn.cbData = cbDataInput;
    LPWSTR pDescrOut = NULL;
 
    //  Begin processing.
 
    printf("The data to be encrypted is: %s\n", pbDataInput);
 
    // Get a handle to the DLL module
 
    /*
    if (HINSTANCE hinstLib = LoadLibrary(TEXT("crypt32.dll")))
    {
        // If the handle is valid, try to get the function address.
 
        if (pCryptProtectData CryptProtectData = (pCryptProtectData) GetProcAddress(hinstLib, "CryptProtectData"))
        {
        */
            // If the function address is valid, call the function
 
            if(CryptProtectData(
                &DataIn,
                L"psw",                             // <---- Need UNICODE also. RDP always sets description to "psw"
                NULL,                               // Optional entropy - not used.
                NULL,                               // Reserved.
                NULL,                               // Pass a PromptStruct.
                CRYPTPROTECT_UI_FORBIDDEN,          // Without user prompt.
                &DataOut))
            {
                // --> DATA_BLOB to HEX string
 
                for (int i = 0; i < (int)DataOut.cbData; i ++)
                {
                    printf("%02X", DataOut.pbData[i]);
                }
            }
            else
            {
                MyHandleError("Encryption error!");
            }
 
            if (CryptUnprotectData(
                &DataOut,
                &pDescrOut,
                NULL,                         // Optional entropy
                NULL,                         // Reserved
                NULL,                         // Optional PromptStruct
                0,
                &DataVerify))
            {
                printf("The decrypted data is: %s\n", DataVerify.pbData);
                printf("The description of the data was: %S\n",pDescrOut);
            }
            else
            {
                MyHandleError("Decryption error!");
            }
 
            //  Clean up.
 
            LocalFree(pDescrOut);
            LocalFree(DataOut.pbData);
 
            /*
        }
 
        // Free the DLL module
 
        BOOL fFreeResult = FreeLibrary(hinstLib);
    }
    */
 
    system("pause");
    return 0;
}
 
void MyHandleError(char *s)
{
    fprintf(stderr,"ERROR: %s\n",s);
    fprintf(stderr, "Error number %x.\n", GetLastError());
    system("pause");
    exit(1);
}

bool AsciiToUnicode(const char* szAscii, wchar_t* szUnicode)
{
    if ((szUnicode == NULL) || (szAscii == NULL))
        return false;
    int len = strlen(szAscii);
    for (int i = 0; i < (len + 1); i ++)
        *szUnicode++ = static_cast<wchar_t> (*szAscii ++);
    return true;
}
 
BOOL AnsiToUnicode16(CHAR *in_Src, WCHAR *out_Dst, INT in_MaxLen)
{
    /* locals */
    INT lv_Len;
 
  // do NOT decrease maxlen for the eos
  if (in_MaxLen <= 0)
    return FALSE;
 
  // let windows find out the meaning of ansi
  // - the SrcLen=-1 triggers MBTWC to add a eos to Dst and fails if MaxLen is too small.
  // - if SrcLen is specified then no eos is added
  // - if (SrcLen+1) is specified then the eos IS added
  lv_Len = MultiByteToWideChar(CP_ACP, 0, in_Src, -1, out_Dst, in_MaxLen);
 
  // validate
  if (lv_Len < 0)
    lv_Len = 0;
 
  // ensure eos, watch out for a full buffersize
  // - if the buffer is full without an eos then clear the output like MBTWC does
  //   in case of too small outputbuffer
  // - unfortunately there is no way to let MBTWC return shortened strings,
  //   if the outputbuffer is too small then it fails completely
  if (lv_Len < in_MaxLen)
    out_Dst[lv_Len] = 0;
  else if (out_Dst[in_MaxLen-1])
    out_Dst[0] = 0;
 
  // done
  return TRUE;
}

#define WINVER 0x0501
#define _WIN32_WINNT 0x0501
#define _WIN32_WINDOWS 0x0501
#define _WIN32_IE 0x0600
 
 
 
#include <iostream>
#include <string>
#include <Windows.h>
 
#include <WinCrypt.h>
#pragma comment(lib, "Crypt32.lib")
 
#include <strsafe.h>
 
 
 
namespace
{
 
 
 
void
_stdcall
throw_exc(char const *pFormat, ...)
{
    using namespace std;
 
    va_list VaList;
    va_start(VaList, pFormat);
 
    size_t const BuffSize = 1000;
    char *pBuffer = new char[BuffSize];
    string ErrMsg;
 
    if (FAILED(StringCchVPrintfA(pBuffer, BuffSize, pFormat, VaList)))
    {
        ErrMsg = pFormat;
    }
 
    else
    {
        ErrMsg = pBuffer;
    }
 
    delete [] pBuffer;
    throw (runtime_error(ErrMsg.c_str()));
}
 
 
 
} // namespace
 
 
 
int main()
{
    using namespace std;
 
    try
    {
        wchar_t *pCmdLine = GetCommandLineW();
 
        if (NULL == pCmdLine)
        {
            throw_exc("GetCommandLineW failed with last error %lu.", GetLastError());
        }
 
        int NumArgs;
        wchar_t **pArgsArray = CommandLineToArgvW(pCmdLine, &NumArgs);
 
        if (NULL == pArgsArray)
        {
            throw_exc("CommandLineToArgvW failed with last error %lu.", GetLastError());
        }
 
        if (2 != NumArgs)
        {
            LocalFree(pArgsArray);
            throw_exc("Wrong arguments number (%lu).", NumArgs);
        }
 
        wstring const Password = pArgsArray[1];
        LocalFree(pArgsArray);
 
        DATA_BLOB BlobIn;
        DATA_BLOB BlobOut;
        BlobIn.pbData = (BYTE *)Password.c_str();
        BlobIn.cbData = static_cast<DWORD>((Password.length() + 1) * sizeof (wchar_t));
 
        if (FALSE == CryptProtectData(&BlobIn,
            L"psw",
            NULL,
            NULL,
            NULL,
            CRYPTPROTECT_UI_FORBIDDEN,
            &BlobOut))
        {
            throw_exc("CryptProtectData failed with last error %lu.", GetLastError());
        }
 
        for (DWORD i = 0; i < BlobOut.cbData; ++i)
        {
            printf("%02X", BlobOut.pbData[i]);
        }
 
        printf("\r\n");
 
        LocalFree(BlobOut.pbData);
    }
 
    catch (exception const &Exc)
    {
        cerr << "ERROR: " << Exc.what() << endl;
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}