# رقم سري هو 648546184764918567949546

import requests
import re
import json
import time
import random
import sys
import os
from datetime import datetime
from fake_useragent import UserAgent
import uuid
import threading

EXPIRY_DATE = datetime(2026, 6, 30, 23, 59, 59)

if datetime.now() > EXPIRY_DATE:
    print("\n" + "="*60)
    print("اداه انتهت اشتراكه يزاحف خش سيرفر دس حق مستر وحط بوستات وتحصلها مفكوكه تشفير او انتضر ليما مستر ضميره يقوم وينشر V2 حق اداه..")
    print("="*60)
    input("\nاضغط Enter للخروج...")
    sys.exit(0)

REQUIRED_FILENAME = "TikByMr.py"

current_filename = os.path.basename(sys.argv[0])

if current_filename != REQUIRED_FILENAME:
    print("\n" + "="*60)
    print("\033[91m ERROR: Invalid filename! \033[0m")
    print("="*60)
    print(f"Current filename: {current_filename}")
    print(f"Required filename: {REQUIRED_FILENAME}")
    print("\nلا تغير اسم الملف!")
    print("="*60)
    input("\nPress Enter to exit...")
    sys.exit(1)

class Colors:
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    PURPLE = '\033[95m'
    WHITE = '\033[97m'
    RESET = '\033[0m'

class TikTokDestroyer:
    def __init__(self):
        self.default_sessions = [
            "b5651b83c3b7df07a37813c47c95a4b7",
            "5ed6b95e33315cd70ec9ba1fea34495c",
            "268cc61bc26245f74fdd61a47975fa99",
            "57685f36f5af2ff4152855cc8ae2c34f"
        ]
        self.sessions = self.default_sessions.copy()
        self.target_username = ""
        self.reports_sent = 0
        self.reports_success = 0
        self.reports_failed = 0
        self.running = False
        self.extracted_data = {}
        self.custom_reports_list = []
        
        self.report_categories = [
            {"id": 1, "name": "Violence and threats", "path": "/api/report/violence"},
            {"id": 2, "name": "Harassment and bullying", "path": "/api/report/harassment"},
            {"id": 3, "name": "Hate speech", "path": "/api/report/hate_speech"},
            {"id": 4, "name": "Nudity and sexual content", "path": "/api/report/nudity"},
            {"id": 5, "name": "Child safety violation", "path": "/api/report/child_safety"},
            {"id": 6, "name": "Self harm", "path": "/api/report/self_harm"},
            {"id": 7, "name": "Scam or fraud", "path": "/api/report/scam"},
            {"id": 8, "name": "Misinformation", "path": "/api/report/misinformation"},
            {"id": 9, "name": "Spam", "path": "/api/report/spam"},
            {"id": 10, "name": "Impersonation", "path": "/api/report/impersonation"},
            {"id": 11, "name": "Illegal activities", "path": "/api/report/illegal"},
            {"id": 12, "name": "Copyright theft", "path": "/api/report/copyright"},
            {"id": 13, "name": "Animal abuse", "path": "/api/report/animal_abuse"},
            {"id": 14, "name": "Terrorism", "path": "/api/report/terrorism"},
            {"id": 15, "name": "Drug abuse", "path": "/api/report/drugs"},
            {"id": 16, "name": "Weapons", "path": "/api/report/weapons"},
            {"id": 17, "name": "Dangerous acts", "path": "/api/report/dangerous"},
            {"id": 18, "name": "Eating disorders", "path": "/api/report/eating"},
            {"id": 19, "name": "Minor endangerment", "path": "/api/report/minor"},
            {"id": 20, "name": "Privacy violation", "path": "/api/report/privacy"},
            {"id": 21, "name": "Doxxing", "path": "/api/report/doxxing"},
            {"id": 22, "name": "Extremism", "path": "/api/report/extremism"},
            {"id": 23, "name": "Human trafficking", "path": "/api/report/trafficking"},
            {"id": 24, "name": "Sexual exploitation", "path": "/api/report/exploitation"},
            {"id": 25, "name": "Fake account", "path": "/api/report/fake"},
            {"id": 26, "name": "Suicide promotion", "path": "/api/report/suicide"},
            {"id": 27, "name": "Gore content", "path": "/api/report/gore"},
            {"id": 28, "name": "Racism", "path": "/api/report/racism"},
            {"id": 29, "name": "Sexual violence", "path": "/api/report/sexual_violence"},
            {"id": 30, "name": "Underage user", "path": "/api/report/underage"}
        ]

    def clear_screen(self):
        os.system('clear' if os.name == 'posix' else 'cls')

    def print_banner(self):
        banner = f"""
{Colors.RED}
████████╗██╗██╗░░██╗████████╗░█████╗░██╗░░██╗
╚══██╔══╝██║██║░██╔╝╚══██╔══╝██╔══██╗██║░██╔╝
░░░██║░░░██║█████═╝░░░░██║░░░██║░░██║█████═╝░
░░░██║░░░██║██╔═██╗░░░░██║░░░██║░░██║██╔═██╗░
░░░██║░░░██║██║░╚██╗░░░██║░░░╚█████╔╝██║░╚██╗
░░░╚═╝░░░╚═╝╚═╝░░╚═╝░░░╚═╝░░░░╚════╝░╚═╝░░╚═╝
{Colors.RESET}
{Colors.WHITE}════════════════════════════════════════════════════════════{Colors.RESET}
{Colors.PURPLE}By Mr{Colors.RESET}
{Colors.YELLOW}https://discord.gg/sqr11{Colors.RESET}
{Colors.WHITE}════════════════════════════════════════════════════════════{Colors.RESET}
"""
        print(banner)

    def print_success(self, msg):
        print(f"{Colors.GREEN}[✓]{Colors.RESET} {msg}")

    def print_error(self, msg):
        print(f"{Colors.RED}[✗]{Colors.RESET} {msg}")

    def print_info(self, msg):
        print(f"{Colors.WHITE}[i]{Colors.RESET} {msg}")

    def print_loading(self):
        chars = "|/-\\"
        for i in range(15):
            sys.stdout.write(f'\r{Colors.WHITE}Extracting {chars[i % 4]}{Colors.RESET}')
            sys.stdout.flush()
            time.sleep(0.05)
        print('\r' + ' ' * 20 + '\r', end='')

    def add_more_sessions(self):
        self.print_info("Enter additional session tokens (type 'done' to finish):")
        new_sessions = []
        while True:
            sess = input(f"{Colors.WHITE}Session > {Colors.RESET}").strip()
            if sess.lower() == "done":
                break
            if sess:
                new_sessions.append(sess)
                self.print_success(f"Added session {len(new_sessions)}")
        if new_sessions:
            self.sessions.extend(new_sessions)
            self.print_success(f"Total sessions: {len(self.sessions)}")

    def extract_profile_data(self, username):
        self.print_info(f"Scanning target: @{username}")
        self.print_loading()
        
        headers = {"User-Agent": UserAgent().random}
        url = f"https://www.tiktok.com/@{username}"
        
        try:
            response = requests.get(url, headers=headers, timeout=15)
            if response.status_code != 200:
                self.print_error("Cannot fetch profile")
                return False
            
            html = response.text
            
            json_match = re.search(r'<script id="__UNIVERSAL_DATA__" type="application/json">(.*?)</script>', html)
            if json_match:
                data = json.loads(json_match.group(1))
                user_info = data.get("__DEFAULT_SCOPE__", {}).get("webapp.user-detail", {}).get("userInfo", {})
                stats = user_info.get("stats", {})
                user_detail = user_info.get("user", {})
                bio = user_detail.get("signature", "")
                nickname = user_detail.get("nickname", "")
                followers = stats.get("followerCount", 0)
                following = stats.get("followingCount", 0)
                likes = stats.get("heartCount", 0)
                videos = stats.get("videoCount", 0)
                region = user_detail.get("region", "Unknown")
            else:
                bio = re.search(r'"signature":"([^"]*?)"', html)
                bio = bio.group(1) if bio else ""
                nickname = re.search(r'"nickname":"([^"]*?)"', html)
                nickname = nickname.group(1) if nickname else ""
                followers = re.search(r'"followerCount":(\d+)', html)
                followers = followers.group(1) if followers else "0"
                following = re.search(r'"followingCount":(\d+)', html)
                following = following.group(1) if following else "0"
                likes = re.search(r'"heartCount":(\d+)', html)
                likes = likes.group(1) if likes else "0"
                videos = re.search(r'"videoCount":(\d+)', html)
                videos = videos.group(1) if videos else "0"
                region = "Unknown"

            # ========== FILTERS ==========
            emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', bio)
            
            phones = re.findall(r'\+?\d{1,4}[-.\s]?\d{8,15}', bio)
            
            links = re.findall(r'https?://[^\s"\'<>]+', bio)
            links += re.findall(r'[a-zA-Z0-9.-]+\.(?:com|net|org|io|me|tv|co|xyz|online|site|club)[^\s]*', bio)
            
            # Instagram
            insta_patterns = [
                r'(?:instagram\.com/|ig\.me/|insta\.)[^\s]+',
                r'(?i)(?:انستا|انستقرام|انستاكرام|انستغرام|انستاقرام|انستا حقي|انستقرام حقي|انس|انستكرام حقي|insta|instagram|inst|ins)[:\s]*([a-zA-Z0-9_.]+)'
            ]
            instagram = []
            for pattern in insta_patterns:
                found = re.findall(pattern, bio)
                for f in found:
                    if isinstance(f, str) and len(f) > 2 and '@' not in f:
                        instagram.append(f)
                    elif isinstance(f, tuple) or isinstance(f, list):
                        for x in f:
                            if isinstance(x, str) and len(x) > 2 and '@' not in x:
                                instagram.append(x)
            
            # YouTube
            youtube = []
            yt_patterns = [
                r'(?:youtube\.com/|youtu\.be/)[^\s]+',
                r'(?i)(?:يوت|يوتيوب|يوت حقي|يوتيوب حقي|Youtube)[:\s]*([a-zA-Z0-9_.]+)'
            ]
            for pattern in yt_patterns:
                found = re.findall(pattern, bio)
                for f in found:
                    if isinstance(f, str) and len(f) > 2:
                        youtube.append(f)
            
            # Telegram
            telegram = []
            tg_patterns = [
                r't\.me/[^\s]+',
                r'telegram\.me/[^\s]+',
                r'(?i)(?:تلي|تليقرام|تليكرام|tele|Telegram)[:\s]*([a-zA-Z0-9_]+)'
            ]
            for pattern in tg_patterns:
                found = re.findall(pattern, bio)
                for f in found:
                    if isinstance(f, str) and len(f) > 2:
                        telegram.append(f)
            
            # Snapchat
            snapchat = []
            snap_patterns = [
                r'snapchat\.com/add/[^\s]+',
                r'(?i)(?:سناب|سناب حقي|Snap)[:\s]*([a-zA-Z0-9_.]+)'
            ]
            for pattern in snap_patterns:
                found = re.findall(pattern, bio)
                for f in found:
                    if isinstance(f, str) and len(f) > 2:
                        snapchat.append(f)
            
            # Discord
            discord = []
            dc_patterns = [
                r'discord\.gg/[^\s]+',
                r'discord\.com/invite/[^\s]+',
                r'(?i)(?:دس|دسكورد|حسابي في دس|Ds|Discord)[:\s]*([a-zA-Z0-9_#]+)'
            ]
            for pattern in dc_patterns:
                found = re.findall(pattern, bio)
                for f in found:
                    if isinstance(f, str) and len(f) > 2:
                        discord.append(f)
            
            twitter = re.findall(r'(?:twitter\.com/|x\.com/)[^\s]+', bio)
            facebook = re.findall(r'(?:facebook\.com/|fb\.com/)[^\s]+', bio)
            twitch = re.findall(r'twitch\.tv/[^\s]+', bio)
            tiktok = re.findall(r'tiktok\.com/@[^\s]+', bio)
            github = re.findall(r'github\.com/[^\s]+', bio)
            linkedin = re.findall(r'linkedin\.com/in/[^\s]+', bio)
            onlyfans = re.findall(r'onlyfans\.com/[^\s]+', bio)
            spotify = re.findall(r'spotify\.com/[^\s]+', bio)
            pinterest = re.findall(r'pinterest\.com/[^\s]+', bio)
            reddit = re.findall(r'reddit\.com/user/[^\s]+', bio)
            whatsapp = re.findall(r'(?:wa\.me/|whatsapp)[:\s]*([0-9+]+)', bio, re.IGNORECASE)
            signal = re.findall(r'signal\.me/[^\s]+', bio)

            print(f"\n{Colors.WHITE}{'='*60}{Colors.RESET}")
            self.print_success(f"TARGET: @{username}")
            print(f"{Colors.WHITE}Nickname    : {Colors.RESET}{nickname}")
            print(f"{Colors.WHITE}Region      : {Colors.RESET}{region}")
            print(f"{Colors.WHITE}Followers   : {Colors.RESET}{followers}")
            print(f"{Colors.WHITE}Following   : {Colors.RESET}{following}")
            print(f"{Colors.WHITE}Total likes : {Colors.RESET}{likes}")
            print(f"{Colors.WHITE}Videos      : {Colors.RESET}{videos}")
            
            print(f"{Colors.WHITE}Bio         : {Colors.RESET}")
            print(f"{Colors.WHITE}             {Colors.RESET}")
            print(f"{Colors.WHITE}             {Colors.RESET}")
            print(f"{Colors.WHITE}             {Colors.RESET}")
            print(f"{Colors.WHITE}             {Colors.RESET}")
            
            bio_lines = bio.split('\n') if bio else []
            if bio_lines:
                for line in bio_lines[:4]:
                    if line.strip():
                        print(f"{Colors.WHITE}             {Colors.RESET}{line.strip()}")
            else:
                print(f"{Colors.WHITE}             {Colors.RESET}No bio available")
            
            if emails:
                print(f"{Colors.RED}Emails      : {Colors.RESET}{', '.join(set(emails))}")
            if phones:
                print(f"{Colors.RED}Phones      : {Colors.RESET}{', '.join(set(phones))}")
            if links:
                print(f"{Colors.RED}Links       : {Colors.RESET}{', '.join(list(set(links))[:3])}")
            if instagram:
                print(f"{Colors.RED}Instagram   : {Colors.RESET}{', '.join(list(set(instagram))[:3])}")
            if youtube:
                print(f"{Colors.RED}YouTube     : {Colors.RESET}{', '.join(list(set(youtube))[:2])}")
            if telegram:
                print(f"{Colors.RED}Telegram    : {Colors.RESET}{', '.join(list(set(telegram))[:2])}")
            if snapchat:
                print(f"{Colors.RED}Snapchat    : {Colors.RESET}{', '.join(list(set(snapchat))[:2])}")
            if discord:
                print(f"{Colors.RED}Discord     : {Colors.RESET}{', '.join(list(set(discord))[:2])}")
            if twitter:
                print(f"{Colors.RED}Twitter/X   : {Colors.RESET}{', '.join(list(set(twitter))[:2])}")
            if facebook:
                print(f"{Colors.RED}Facebook    : {Colors.RESET}{', '.join(list(set(facebook))[:2])}")
            if twitch:
                print(f"{Colors.RED}Twitch      : {Colors.RESET}{', '.join(list(set(twitch))[:2])}")
            if tiktok:
                print(f"{Colors.RED}TikTok      : {Colors.RESET}{', '.join(list(set(tiktok))[:2])}")
            if github:
                print(f"{Colors.RED}GitHub      : {Colors.RESET}{', '.join(list(set(github))[:2])}")
            if linkedin:
                print(f"{Colors.RED}LinkedIn    : {Colors.RESET}{', '.join(list(set(linkedin))[:2])}")
            if onlyfans:
                print(f"{Colors.RED}OnlyFans    : {Colors.RESET}{', '.join(list(set(onlyfans))[:2])}")
            if spotify:
                print(f"{Colors.RED}Spotify     : {Colors.RESET}{', '.join(list(set(spotify))[:2])}")
            if pinterest:
                print(f"{Colors.RED}Pinterest   : {Colors.RESET}{', '.join(list(set(pinterest))[:2])}")
            if reddit:
                print(f"{Colors.RED}Reddit      : {Colors.RESET}{', '.join(list(set(reddit))[:2])}")
            if whatsapp:
                print(f"{Colors.RED}WhatsApp    : {Colors.RESET}{', '.join(list(set(whatsapp))[:2])}")
            if signal:
                print(f"{Colors.RED}Signal      : {Colors.RESET}{', '.join(list(set(signal))[:2])}")
            
            print(f"{Colors.WHITE}{'='*60}{Colors.RESET}\n")
            return True

        except Exception as e:
            self.print_error(f"Extraction failed: {str(e)}")
            return False

    def send_report(self, session, report_data):
        servers = [
            "https://www.tiktok.com",
            "https://api.tiktok.com",
            "https://www.tiktok.com/api"
        ]
        server = random.choice(servers)
        url = server + report_data["path"]
        
        cookies = {"sessionid": session}
        headers = {
            "User-Agent": UserAgent().random,
            "Content-Type": "application/json",
            "Accept": "application/json",
            "Referer": f"https://www.tiktok.com/@{self.target_username}",
            "Origin": "https://www.tiktok.com"
        }
        payload = {
            "target_username": self.target_username,
            "report_category": report_data["name"],
            "reason_code": report_data["id"],
            "description": f"URGENT: {report_data['name']} - This account violates TikTok Community Guidelines repeatedly. Multiple violations detected. Request immediate investigation and permanent account suspension.",
            "report_type": "account",
            "source": "web",
            "timestamp": int(time.time()),
            "report_id": str(uuid.uuid4())
        }
        
        try:
            response = requests.post(url, json=payload, cookies=cookies, headers=headers, timeout=8)
            return response.status_code in [200, 201, 202, 204]
        except:
            return False

    def display_report_menu(self):
        print(f"\n{Colors.WHITE}{'═'*60}{Colors.RESET}")
        self.print_info("AVAILABLE REPORT TYPES (30 categories):")
        for idx, r in enumerate(self.report_categories, 1):
            if idx <= 10:
                color = Colors.RED
            elif idx <= 20:
                color = Colors.YELLOW
            else:
                color = Colors.GREEN
            print(f"{color}{idx:2}. {r['name']}{Colors.RESET}")
        print(f"{Colors.WHITE}{'═'*60}{Colors.RESET}")

    def select_reports_with_count(self, num_reports):
        self.custom_reports_list = []
        self.display_report_menu()
        
        for i in range(num_reports):
            self.print_info(f"Select report #{i+1}:")
            choice = input(f"{Colors.WHITE}Choice (1-30): {Colors.RESET}").strip()
            try:
                idx = int(choice) - 1
                if 0 <= idx < len(self.report_categories):
                    self.custom_reports_list.append(self.report_categories[idx])
                    self.print_success(f"Added: {self.report_categories[idx]['name']}")
                else:
                    self.custom_reports_list.append(random.choice(self.report_categories))
            except:
                self.custom_reports_list.append(random.choice(self.report_categories))

    def attack_worker(self, thread_id):
        session_idx = thread_id % len(self.sessions)
        report_idx = 0
        while self.running:
            try:
                session = self.sessions[session_idx % len(self.sessions)]
                report_data = self.custom_reports_list[report_idx % len(self.custom_reports_list)]
                
                success = self.send_report(session, report_data)
                self.reports_sent += 1
                
                if success:
                    self.reports_success += 1
                    print(f"{Colors.GREEN}[#{self.reports_sent}] SUCCESS{Colors.RESET} | {report_data['name'][:40]}")
                else:
                    self.reports_failed += 1
                    print(f"{Colors.RED}[#{self.reports_sent}] FAILED{Colors.RESET} | {report_data['name'][:40]}")

                session_idx += 1
                report_idx += 1

                if self.reports_sent % 20 == 0:
                    print(f"\n{Colors.WHITE}{'═'*50}{Colors.RESET}")
                    self.print_info(f"SENT:{self.reports_sent} OK:{self.reports_success} FAIL:{self.reports_failed}")
                    print(f"{Colors.WHITE}{'═'*50}{Colors.RESET}\n")

                time.sleep(random.uniform(0.1, 0.3))

            except Exception as e:
                self.print_error(f"Thread error: {str(e)}")
                time.sleep(0.5)

    def attack_loop(self):
        if not self.custom_reports_list:
            self.custom_reports_list = self.report_categories.copy()
        
        self.running = True
        self.reports_sent = 0
        self.reports_success = 0
        self.reports_failed = 0

        print(f"\n{Colors.WHITE}{'═'*60}{Colors.RESET}")
        self.print_success(f"ATTACK STARTED on @{self.target_username}")
        print(f"{Colors.WHITE}Sessions: {len(self.sessions)}{Colors.RESET}")
        print(f"{Colors.WHITE}Reports: {len(self.custom_reports_list)}{Colors.RESET}")
        print(f"{Colors.WHITE}Threads: 40{Colors.RESET}")
        print(f"{Colors.WHITE}{'═'*60}{Colors.RESET}\n")

        threads = []
        for i in range(40):
            t = threading.Thread(target=self.attack_worker, args=(i,))
            t.daemon = True
            t.start()
            threads.append(t)
        
        try:
            while self.running:
                time.sleep(1)
        except KeyboardInterrupt:
            self.running = False
            print(f"\n{Colors.RED}Attack stopped{Colors.RESET}")

    def run(self):
        self.clear_screen()
        self.print_banner()
        
        self.target_username = input(f"{Colors.WHITE}Enter username: {Colors.RESET}").strip()
        if not self.target_username:
            self.print_error("No username")
            return
        
        self.extract_profile_data(self.target_username)
        
        # ========== ADD SESSIONS OPTION ==========
        session_choice = input(f"\n{Colors.WHITE}Add sessions? (y/n): {Colors.RESET}").strip().lower()
        if session_choice == "y":
            self.add_more_sessions()
        # ==========================================
        
        custom = input(f"{Colors.WHITE}Custom reports? (y/n): {Colors.RESET}").strip().lower()
        if custom == "y":
            num = input(f"{Colors.WHITE}Number of reports: {Colors.RESET}").strip()
            try:
                self.select_reports_with_count(int(num))
            except:
                self.custom_reports_list = self.report_categories.copy()
        else:
            self.custom_reports_list = self.report_categories.copy()
        
        self.attack_loop()

if __name__ == "__main__":
    destroyer = TikTokDestroyer()
    destroyer.run()