Как получить HEX строку из byte?

void ByteToHex(char Hex[], byte Sourse[])
{
    char const hex_chars[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
    for(int j = 0, i = 0; i < 20; ++i)
    {
        Hex[j++] += hex_chars[(Sourse[i] & 0xF0) >> 4];
        Hex[j++] += hex_chars[(Sourse[i] & 0x0F) >> 0];
    }
}

for(int i = 0; i < 20; ++i) cout << (Sourse[] << 16) << (Sourse[] << 8);

void ByteToHex(char *Hex, byte Sourse[])
{
    char const hex_chars[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
    for(int j = 0, i = 0; i < 20; ++i)
    {
        *Hex++ = hex_chars[(Sourse[i] & 0xF0) >> 4];
        *Hex++ = hex_chars[Sourse[i] & 0xF];
    }
    *Hex = '\0';
}

byte result[40]; // В ней строки
 
char Hex[80]; Byte2Hex(result, Hex);
MessageBoxA(hWnd, Hex, "HEX", 0);

void Byte2Hex(BYTE bValue[], char * lpBuff)
{
    char const hex_chars[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
    for(int j = 0, i = 0; i < 20; ++i)
    {
        lpBuff[j++] += hex_chars[(bValue[i] & 0xF0) >> 4];
        lpBuff[j++] += hex_chars[(bValue[i] & 0x0F) >> 0];
    }
}

void Byte2Hex(BYTE bValue[], char * lpBuff)
{
    char const hex_chars[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
    int size = strlen((char *)bValue);
 
    for(int j = 0, i = 0; i < size; ++i)
    {
        lpBuff[j++] += hex_chars[(bValue[i] & 0xF0) >> 4];
        lpBuff[j++] += hex_chars[(bValue[i] & 0x0F) >> 0];
    }
    *lpBuff = '\0';
}

#include <SDKDDKVer.h>
#include <windows.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <commctrl.h>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include "resource.h"
#include "aes.h"
#include "sha1.h"
 
#pragma comment(linker, "/manifestdependency:"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'"")
 
#define MAX_LOADSTRING  100
#define MAXPASSWORD     128
#define SIZE_SALT30     8
#define ASIZE(x)        (sizeof(x)/sizeof(x[0]))
 
HINSTANCE hInst;
TCHAR szTitle[MAX_LOADSTRING], szWindowClass[MAX_LOADSTRING];
 
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
 
HWND hEdit[7], hButton[10], hCombobox;
RECT rSize;
HBRUSH hBrush;
 
 
 
void Byte2Hex(BYTE bValue[], char * lpBuff)
{
    char const hex_chars[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
    int size = strlen((char *)bValue);
 
    for(int j = 0, i = 0; i < size; ++i)
    {
        lpBuff[j++] += hex_chars[(bValue[i] & 0xF0) >> 4];
        lpBuff[j++] += hex_chars[(bValue[i] & 0x0F) >> 0];
    }
    *lpBuff = '\0';
}
void SetStaticColorTextW(HWND hWnd, HDC hDc, COLORREF rgbpack, LPCWSTR text)
{
    SetTextColor(hDc, rgbpack);
    SetWindowTextW(hWnd, text);
}
byte* WideToRaw(const wchar_t * Src, byte * Dest, size_t SrcSize)
{
    for(size_t I = 0; I < SrcSize; I++, Src++)
    {
        Dest[I * 2] = (byte) * Src;
        Dest[I * 2 + 1] = (byte)(* Src >> 8);
        if(* Src == 0) break;
    }
    return Dest;
}
void AesKeyExpansion(byte Key[16], int KeyLenght, unsigned int digest[5])
{
    switch(KeyLenght)
    {
        case 128:
        {
            for(int I = 0; I < 4; I++)
            {
                for(int J = 0; J < 4; J++) Key[I * 4 + J] = (byte)(digest[I] >> (J * 8));
            }
            break;
        }
        case 192:
        {
            break;
        }
        case 256:
        {
            break;
        }
    }
}
 
int APIENTRY _tWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPTSTR  lpCmdLine, _In_ int   nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    MSG msg;
    HACCEL hAccelTable;
 
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_AESUNCRIPT, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    if(!InitInstance(hInstance, nCmdShow)) return FALSE;
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_AESUNCRIPT));
 
    while(GetMessage(&msg, NULL, NULL, NULL))
    {
        if(TranslateAccelerator(msg.hwnd, hAccelTable, &msg) != NULL) continue;
 
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return (int)msg.wParam;
}
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = NULL;
    wcex.cbWndExtra     = NULL;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_AESUNCRIPT));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_AESUNCRIPT);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance;
 
    GetWindowRect(GetDesktopWindow(), &rSize);
    HWND hWnd; hWnd = CreateWindowExW(NULL, szWindowClass, szTitle, WS_OVERLAPPEDWINDOW, rSize.left, rSize.top, rSize.right, rSize.bottom, NULL, NULL, hInstance, NULL);
    if(!hWnd) return FALSE;
 
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
 
    return TRUE;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_CREATE:
        {
            HFONT hFont; hFont = CreateFont(16, NULL, NULL, NULL, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, TEXT("Arial"));
 
            hEdit[0] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_STATIC, NULL, WS_CHILD | WS_VISIBLE, 36, 10, 1219, 20, hWnd, NULL, hInst, NULL);
            hEdit[1] = CreateWindowExW(WS_EX_STATICEDGE, WC_EDIT, NULL, WS_CHILD | WS_VISIBLE | WS_DLGFRAME | ES_MULTILINE | WS_HSCROLL | WS_VSCROLL, 36, 35, 1218, 260, hWnd, NULL, hInst, NULL);
            hEdit[2] = CreateWindowExW(WS_EX_STATICEDGE, WC_EDIT, NULL, WS_CHILD | WS_VISIBLE | WS_DLGFRAME | ES_AUTOHSCROLL, 81, 305, 1174, 25, hWnd, NULL, hInst, NULL);
            hEdit[3] = CreateWindowExW(WS_EX_STATICEDGE, WC_EDIT, NULL, WS_CHILD | WS_VISIBLE | WS_DLGFRAME | ES_AUTOHSCROLL, 81, 330, 1174, 25, hWnd, NULL, hInst, NULL);
            hEdit[4] = CreateWindowExW(WS_EX_STATICEDGE, WC_EDIT, NULL, WS_CHILD | WS_VISIBLE | WS_DLGFRAME | ES_AUTOHSCROLL, 81, 355, 1174, 25, hWnd, NULL, hInst, NULL);
            hEdit[5] = CreateWindowExW(WS_EX_STATICEDGE, WC_EDIT, NULL, WS_CHILD | WS_VISIBLE | WS_DLGFRAME | ES_MULTILINE | WS_HSCROLL | WS_VSCROLL, 36, 425, 1218, 260, hWnd, NULL, hInst, NULL);
            hEdit[6] = CreateWindowExW(WS_EX_STATICEDGE, WC_EDIT, NULL, WS_CHILD | WS_VISIBLE | WS_DLGFRAME | ES_MULTILINE | WS_HSCROLL | WS_VSCROLL, 36, 695, 1218, 260, hWnd, NULL, hInst, NULL);
 
            hButton[0] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"Закодировать", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 120, 390, 110, 25, hWnd, (HMENU)1, hInst, NULL);
            hButton[1] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"Декодировать", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 240, 390, 110, 25, hWnd, (HMENU)2, hInst, NULL);
            hButton[2] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"Выявить пароль", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 360, 390, 120, 25, hWnd, (HMENU)3, hInst, NULL);
            hButton[3] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"Очистить всё", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 490, 390, 110, 25, hWnd, (HMENU)4, hInst, NULL);
            hButton[4] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"О\nч\nи\nс\nт\nи\nт\nь", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_MULTILINE, 10, 35, 25, 260, hWnd, (HMENU)5, hInst, NULL);
            hButton[5] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"Очистить", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 305, 70, 25, hWnd, (HMENU)6, hInst, NULL);
            hButton[6] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"Очистить", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 330, 70, 25, hWnd, (HMENU)7, hInst, NULL);
            hButton[7] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"Очистить", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 355, 70, 25, hWnd, (HMENU)8, hInst, NULL);
            hButton[8] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"О\nч\nи\nс\nт\nи\nт\nь", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_MULTILINE, 10, 425, 25, 260, hWnd, (HMENU)9, hInst, NULL);
            hButton[9] = CreateWindowExW(WS_EX_WINDOWEDGE, WC_BUTTON, L"О\nч\nи\nс\nт\nи\nт\nь", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_MULTILINE, 10, 695, 25, 260, hWnd, (HMENU)10, hInst, NULL);
 
            hCombobox = CreateWindowExW(NULL, WC_COMBOBOX, NULL, WS_CHILD | WS_VISIBLE | WS_VSCROLL | CBS_AUTOHSCROLL | CBS_DROPDOWNLIST, 10, 390, 100, 75, hWnd, (HMENU)5, hInst, NULL);
 
            SendMessageW(hEdit[1], EM_SETCUEBANNER, NULL, (LPARAM)L"Исходный текст");
            SendMessageW(hEdit[2], EM_SETCUEBANNER, NULL, (LPARAM)L"Пароль (текст)");
            SendMessageW(hEdit[3], EM_SETCUEBANNER, NULL, (LPARAM)L"Пароль (md5)");
            SendMessageW(hEdit[4], EM_SETCUEBANNER, NULL, (LPARAM)L"Пароль (aes key)");
            SendMessageW(hEdit[5], EM_SETCUEBANNER, NULL, (LPARAM)L"Закодированный текст");
            SendMessageW(hEdit[6], EM_SETCUEBANNER, NULL, (LPARAM)L"Закодированный текст (hex)");
 
            SendMessageA(hCombobox, CB_ADDSTRING, NULL, (LPARAM)" AES - 128");
            SendMessageA(hCombobox, CB_ADDSTRING, NULL, (LPARAM)" AES - 192");
            SendMessageA(hCombobox, CB_ADDSTRING, NULL, (LPARAM)" AES - 156");
            SendMessageW(hCombobox, CB_SETCURSEL, NULL, NULL);
            SendMessageW(hCombobox, WM_SETFONT, WPARAM(hFont), TRUE);
 
            SendMessageW(hEdit[1], EM_SETLIMITTEXT, (WPARAM)10000, NULL);
            SendMessageW(hEdit[2], EM_SETLIMITTEXT, (WPARAM)510, NULL);
            SendMessageW(hEdit[3], EM_SETLIMITTEXT, (WPARAM)40, NULL);
            SendMessageW(hEdit[4], EM_SETLIMITTEXT, (WPARAM)256, NULL);
            SendMessageW(hEdit[5], EM_SETLIMITTEXT, (WPARAM)10000, NULL);
            SendMessageW(hEdit[6], EM_SETLIMITTEXT, (WPARAM)10000, NULL);
 
            SendMessageW(hEdit[1], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[2], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[3], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[4], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[5], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[6], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[7], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[8], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hEdit[9], WM_SETFONT, WPARAM(hFont), TRUE);
 
            SendMessageW(hButton[0], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[1], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[2], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[3], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[4], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[5], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[6], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[7], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[8], WM_SETFONT, WPARAM(hFont), TRUE);
            SendMessageW(hButton[9], WM_SETFONT, WPARAM(hFont), TRUE);
            break;
        }
        case WM_COMMAND:
        {
            switch(LOWORD(wParam))
            {
                case 1:
                {
                    int eLen[4];
                    eLen[0] = GetWindowTextLengthW(hEdit[1]); // Текст
                    eLen[1] = GetWindowTextLengthW(hEdit[2]); // Пароль
                    eLen[2] = GetWindowTextLengthW(hEdit[3]); // Пароль sha1
                    eLen[3] = GetWindowTextLengthW(hEdit[4]); // Пароль aes
 
                    if(!eLen[0] && !(eLen[1] || eLen[2] || eLen[3]))
                    {
                        SetWindowTextW(hEdit[0], L" Вы не указали текст для шифрования и пароль");
                        break;
                    }
                    else if(!eLen[0])
                    {
                        SetWindowTextW(hEdit[0], L" Укажите текст для шифрования");
                        break;
                    }
                    else if(!(eLen[1] || eLen[2] || eLen[3]))
                    {
                        SetWindowTextW(hEdit[0], L" Одно из полей "пароль" должно быть указано");
                        break;
                    }
                    else if((eLen[1] && eLen[2]) || (eLen[1] && eLen[3]) || (eLen[2] && eLen[3]) || (eLen[1] && eLen[2] && eLen[3]))
                    {
                        SetWindowTextW(hEdit[0], L" Только одно из полей "пароль" должно быть указано");
                        break;
                    }
                    SetStaticColorTextW(hEdit[0], (HDC)wParam, RGB(255, 255, 0), L" Обработка...");
 
                    int KeyLenght; // Длина ключа
 
                    switch(SendMessageW(hCombobox, CB_GETCURSEL, NULL, NULL)) // Длина ключа
                    {
                        case 1: // 128
                        {
                            KeyLenght = 128;
                            break;
                        }
                        case 2: // 192
                        {
                            KeyLenght = 192;
                            break;
                        }
                        case 3: // 256
                        {
                            KeyLenght = 256;
                            break;
                        }
                    }
 
                    //aes crypto;                       // Структура, или что - то там...
                    //byte bPass[256];              // Пароль в однобайтовой строке [264]
                    //byte AESKey[16], AESInit[16]; // 128 битный ключ AES, 
 
                    if(eLen[1]) // Если указан текстовый пароль
                    {
                        wchar_t wPass[128]; GetWindowTextW(hEdit[1], wPass, 129); // Получить текст из формы в двухбайтовую строку
 
                         // Получить хэш из пароля
                        sha1_ctx ctx; sha1_init(&ctx); // Инициализация
                        sha1_update(&ctx, reinterpret_cast<const byte *>(wPass), wcslen(wPass) * sizeof(wchar_t)); // Запихнуть пароль в sha1
                        byte result[40]; sha1_final(&ctx, result); // Результат
 
                        MessageBoxA(hWnd, (LPCSTR)result, "BYTE", 0);
 
                        char Hex[81]; Byte2Hex(result, Hex);
                        MessageBoxA(hWnd, Hex, "HEX", 0);
 
 
 
                        //AesKeyExpansion(AESKey, 128, iSha1); // Сгенерировать пароль из хэша
                    }
                    else if(eLen[2]) // sha1 пароль
                    {
                        //GetWindowTextW(hEdit[2], tKey, eLen[2] + 1);
                    }
                    else if(eLen[3]) // aes пароль
                    {
                        
                        //GetWindowTextW(hEdit[3], tKey, eLen[3] + 1);
                    }
                    
 
 
                    /*crypto.expand_key(AESKey, KeyLenght);
 
                    LPWSTR wText = (LPWSTR)malloc(eLen[0] * sizeof(LPWSTR));
                    GetWindowTextW(hEdit[0], wText, eLen[0] + 1);
 
                    byte bText = (byte)malloc(eLen[0] * 2);
                    std::copy(wText, wText + eLen[0], reinterpret_cast<LPWSTR *>(bText));
                    //WideToRaw(PwdW, RawPsw, ASIZE(RawPsw));
 
                    byte buf[crypto.block_size];
                    byte feedback[crypto.block_size] = {0};
                    unsigned chunk = 0;
 
                    while(chunk < eLen[0]);
                    {
                        //sread(buf, sizeof(byte), chunk += crypto.block_size
                            strncpy_s(buf, r2, crypto.block_size);
 
                        // CBC mode.
                        // Обратная cвязь по шифротексту.
 
                        if (whats_to_do == &aes::encrypt)
                        {
                            // Если считано меньше, чем минимально допустимый блок,
                            // дополняем буфер нулями.
                            for (int pos = 0; pos < crypto.block_size; pos++) buf[pos] = (unsigned)pos < chunk ? buf[pos] ^ feedback[pos] : 0;
                            (crypto.*whats_to_do)(buf, buf);
                            memcpy(feedback, buf, crypto.block_size);
                        }
 
                        if (whats_to_do == &aes::decrypt)
                        {
                            byte    plain[crypto.block_size];
                            (crypto.*whats_to_do)(buf, plain);
                            for (int pos = 0; pos < crypto.block_size; pos++)
                            {
                                byte tmp = buf[pos];
                                buf[pos] = plain[pos] ^ feedback[pos];
                                feedback[pos] = tmp;
                            }
                        }
                        strcat(r1, buf)ж
 
                        if (fwrite(buf, sizeof(byte), crypto.block_size, out) < crypto.block_size)
                        {
                            printf("error: can't write to file `%s'.", argument[i]);
                            break;
                        }
                    }
                    */
                    break;
                }
                case 2:
                {
 
                    break;
                }
                case 3:
                {
 
                    break;
                }
                case 4:
                {
                    SetWindowTextW(hEdit[0], L"");
                    SetWindowTextW(hEdit[1], L"");
                    SetWindowTextW(hEdit[2], L"");
                    SetWindowTextW(hEdit[3], L"");
                    SetWindowTextW(hEdit[4], L"");
                    SetWindowTextW(hEdit[5], L"");
                    SetWindowTextW(hEdit[6], L"");
                    break;
                }
                case 5:
                {
                    SetWindowTextW(hEdit[1], L"");
                    break;
                }
                case 6:
                {
                    SetWindowTextW(hEdit[2], L"");
                    break;
                }
                case 7:
                {
                    SetWindowTextW(hEdit[3], L"");
                    break;
                }
                case 8:
                {
                    SetWindowTextW(hEdit[4], L"");
                    break;
                }
                case 9:
                {
                    SetWindowTextW(hEdit[5], L"");
                    break;
                }
                case 10:
                {
                    SetWindowTextW(hEdit[6], L"");
                    break;
                }
            }
            break;
        }
        case WM_CTLCOLORSTATIC:
        {
            SetTextColor((HDC)wParam, RGB(255, 0, 0));
            SetBkMode(HDC(wParam), TRANSPARENT);
            return (LRESULT)hBrush;
        }

case WM_CTLCOLOREDIT:
        {
            SetTextColor((HDC)wParam, RGB(110, 110, 110));
            //SetBkMode((HDC)wParam, TRANSPARENT);
            return (DWORD)GetSysColorBrush(COLOR_WINDOW);
        }
        case WM_PAINT:
        {
            PAINTSTRUCT ps; HDC hdc = BeginPaint(hWnd, &ps);
            HFONT hFont; hFont = CreateFont(48, 0, 0, 0, FW_DONTCARE, FALSE, TRUE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, VARIABLE_PITCH, TEXT("Impact"));
            SelectObject(hdc, hFont);
            hBrush = CreateSolidBrush(RGB(200, 200, 200));
            FillRect(hdc, &rSize, hBrush);
            EndPaint(hWnd, &ps);
            break;
        }
        case WM_DESTROY:
        {
            PostQuitMessage(0);
            break;
        }
        default: return DefWindowProcW(hWnd, message, wParam, lParam);
    }
    return 0;
}case WM_CTLCOLOREDIT:
        {
            SetTextColor((HDC)wParam, RGB(110, 110, 110));
            //SetBkMode((HDC)wParam, TRANSPARENT);
            return (DWORD)GetSysColorBrush(COLOR_WINDOW);
        }
        case WM_PAINT:
        {
            PAINTSTRUCT ps; HDC hdc = BeginPaint(hWnd, &ps);
            HFONT hFont; hFont = CreateFont(48, 0, 0, 0, FW_DONTCARE, FALSE, TRUE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, VARIABLE_PITCH, TEXT("Impact"));
            SelectObject(hdc, hFont);
            hBrush = CreateSolidBrush(RGB(200, 200, 200));
            FillRect(hdc, &rSize, hBrush);
            EndPaint(hWnd, &ps);
            break;
        }
        case WM_DESTROY:
        {
            PostQuitMessage(0);
            break;
        }
        default: return DefWindowProcW(hWnd, message, wParam, lParam);
    }
    return 0;
}

void Byte2Hex(BYTE bValue[], char lpBuff[])
{
    char const hex_chars[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
    int size = strlen((char *)bValue);
    int j = 0;
    int i = -1;
 
    while(++i < size)
    {
        lpBuff[j++] += hex_chars[(bValue[i] & 0xF0) >> 4];
        lpBuff[j++] += hex_chars[(bValue[i] & 0x0F) >> 0];
    }
    lpBuff[j] = '\0';
}