Spaces:
Paused
Paused
| import requests , os , psutil , sys , jwt , pickle , json , binascii , time , urllib3 , base64 , datetime , re , socket , threading , ssl , pytz , aiohttp | |
| from protobuf_decoder.protobuf_decoder import Parser | |
| from xC4 import * ; from xHeaders import * | |
| from datetime import datetime | |
| from google.protobuf.timestamp_pb2 import Timestamp | |
| from concurrent.futures import ThreadPoolExecutor | |
| from threading import Thread | |
| from Pb2 import DEcwHisPErMsG_pb2 , MajoRLoGinrEs_pb2 , PorTs_pb2 , MajoRLoGinrEq_pb2 , sQ_pb2 , Team_msg_pb2 | |
| from cfonts import render, say | |
| #EMOTES BY MatrixCoder | |
| urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) | |
| # Global variables for API access - FILE START में | |
| online_writer = None | |
| whisper_writer = None | |
| key = None | |
| iv = None | |
| region = None | |
| # बाकी सब कुछ वैसा ही रहने दें... | |
| # ... rest of your existing global variables | |
| spam_room = False | |
| spammer_uid = None | |
| spam_chat_id = None | |
| spam_uid = None | |
| Spy = False | |
| Chat_Leave = False | |
| # Add to main.py at top with other globals: | |
| team_members_data = [] | |
| team_history = [] | |
| current_team_leader = None | |
| team_collection_active = False | |
| last_member_update = None | |
| previous_team_state = set() | |
| previous_team_uids = set() # Track previous state | |
| #################################### | |
| Hr = { | |
| 'User-Agent': "Dalvik/2.1.0 (Linux; U; Android 11; ASUS_Z01QD Build/PI)", | |
| 'Connection': "Keep-Alive", | |
| 'Accept-Encoding': "gzip", | |
| 'Content-Type': "application/x-www-form-urlencoded", | |
| 'Expect': "100-continue", | |
| 'X-Unity-Version': "2018.4.11f1", | |
| 'X-GA': "v1 1", | |
| 'ReleaseVersion': "OB52"} | |
| def get_random_color(): | |
| colors = [ | |
| "[FF0000]", "[00FF00]", "[0000FF]", "[FFFF00]", "[FF00FF]", "[00FFFF]", "[FFFFFF]", "[FFA500]", | |
| "[A52A2A]", "[800080]", "[000000]", "[808080]", "[C0C0C0]", "[FFC0CB]", "[FFD700]", "[ADD8E6]", | |
| "[90EE90]", "[D2691E]", "[DC143C]", "[00CED1]", "[9400D3]", "[F08080]", "[20B2AA]", "[FF1493]", | |
| "[7CFC00]", "[B22222]", "[FF4500]", "[DAA520]", "[00BFFF]", "[00FF7F]", "[4682B4]", "[6495ED]", | |
| "[5F9EA0]", "[DDA0DD]", "[E6E6FA]", "[B0C4DE]", "[556B2F]", "[8FBC8F]", "[2E8B57]", "[3CB371]", | |
| "[6B8E23]", "[808000]", "[B8860B]", "[CD5C5C]", "[8B0000]", "[FF6347]", "[FF8C00]", "[BDB76B]", | |
| "[9932CC]", "[8A2BE2]", "[4B0082]", "[6A5ACD]", "[7B68EE]", "[4169E1]", "[1E90FF]", "[191970]", | |
| "[00008B]", "[000080]", "[008080]", "[008B8B]", "[B0E0E6]", "[AFEEEE]", "[E0FFFF]", "[F5F5DC]", | |
| "[FAEBD7]" | |
| ] | |
| return random.choice(colors) | |
| # | |
| # ============================================ | |
| # BROADCAST FUNCTION - WebSocket Updates | |
| # ============================================ | |
| def broadcast_team_change(event_type, team_data): | |
| """Broadcast team changes to WebSocket clients with data validation""" | |
| try: | |
| # Validate data before sending | |
| if event_type in ['member_joined', 'member_left']: | |
| player = team_data.get('player', {}) | |
| # Ensure all required fields exist | |
| validated_player = { | |
| 'uid': str(player.get('uid', 'unknown')), | |
| 'name': player.get('name', 'Unknown'), | |
| 'region': player.get('region', 'UNK'), | |
| 'level': int(player.get('level', 0)), | |
| 'character': str(player.get('character', 'Unknown')), | |
| 'position': player.get('position', 'Member') | |
| } | |
| team_data['player'] = validated_player | |
| # Debug log | |
| print(f"[WS-PREP] {event_type}: {validated_player['name']} (Level {validated_player['level']})") | |
| from api import broadcast_team_update | |
| broadcast_team_update(event_type, team_data) | |
| except Exception as e: | |
| print(f"[WS-ERROR] Failed to broadcast: {e}") | |
| # ============================================ | |
| # TEAM COLLECTION WITH STATE MANAGEMENT | |
| # ============================================ | |
| async def collect_team_members_dynamic(packet_type, parsed_data): | |
| """Team collection with proper state management and WebSocket broadcasting""" | |
| global team_members_data, current_team_leader, team_collection_active | |
| global last_member_update, previous_team_uids | |
| try: | |
| if packet_type != '0500_LARGE': | |
| return False | |
| new_members = [] | |
| # Leader detection | |
| if '1' in parsed_data and parsed_data['1'].get('data'): | |
| leader_uid = parsed_data['1']['data'] | |
| if leader_uid != current_team_leader: | |
| current_team_leader = leader_uid | |
| leader_info = await extract_complete_player_info(parsed_data, leader_uid, "Leader") | |
| if leader_info and leader_info['name'] != "Player_Unknown": | |
| if not any(m['uid'] == str(leader_uid) for m in new_members): | |
| new_members.append(leader_info) | |
| # Deep scan | |
| deep_players = await deep_scan_for_players(parsed_data) | |
| for player in deep_players: | |
| if not any(m['uid'] == player['uid'] for m in new_members): | |
| new_members.append(player) | |
| # Field structures | |
| if '5' in parsed_data and 'data' in parsed_data['5']: | |
| squad_data = parsed_data['5']['data'] | |
| field6_players = await extract_from_field_structure_fixed(squad_data) | |
| for player in field6_players: | |
| if not any(m['uid'] == player['uid'] for m in new_members): | |
| new_members.append(player) | |
| # Nested | |
| if '3' in squad_data and 'data' in squad_data['3']: | |
| nested_data = squad_data['3']['data'] | |
| nested_players = await extract_from_field_structure_fixed(nested_data) | |
| for player in nested_players: | |
| if not any(m['uid'] == player['uid'] for m in new_members): | |
| new_members.append(player) | |
| # ========== STATE CHANGE DETECTION ========== | |
| current_uids = set(m['uid'] for m in new_members) | |
| # Detect JOINED players | |
| joined = current_uids - previous_team_uids | |
| if joined: | |
| for uid in joined: | |
| player = next((m for m in new_members if m['uid'] == uid), None) | |
| if player: | |
| print(f"[TEAM] + {player['name']} joined") | |
| # Broadcast join event with COMPLETE data | |
| broadcast_team_change('member_joined', { | |
| 'player': { | |
| 'uid': player['uid'], | |
| 'name': player['name'], | |
| 'region': player['region'], | |
| 'level': player['level'], | |
| 'character': player.get('character', 'Unknown'), | |
| 'position': player['position'] | |
| }, | |
| 'total_members': len(current_uids) | |
| }) | |
| # Detect LEFT/KICKED players | |
| left = previous_team_uids - current_uids | |
| if left: | |
| for uid in left: | |
| old_player = next((m for m in team_members_data if m['uid'] == uid), None) | |
| if old_player: | |
| print(f"[TEAM] - {old_player['name']} left") | |
| # Broadcast leave event with COMPLETE data | |
| broadcast_team_change('member_left', { | |
| 'player': { | |
| 'uid': old_player['uid'], | |
| 'name': old_player['name'], | |
| 'region': old_player['region'], | |
| 'level': old_player['level'], | |
| 'character': old_player.get('character', 'Unknown'), | |
| 'position': old_player['position'] | |
| }, | |
| 'total_members': len(current_uids) | |
| }) | |
| # Update global state with ONLY current members | |
| team_members_data.clear() | |
| team_members_data.extend(new_members) | |
| previous_team_uids = current_uids | |
| # Update team status | |
| if len(new_members) > 0: | |
| if not team_collection_active: | |
| print(f"[TEAM] ✓ Joined team ({len(new_members)} members)") | |
| # Broadcast team joined with COMPLETE member data | |
| broadcast_team_change('team_joined', { | |
| 'in_team': True, | |
| 'total_members': len(new_members), | |
| 'leader_uid': str(current_team_leader) if current_team_leader else None, | |
| 'members': [ | |
| { | |
| 'uid': m['uid'], | |
| 'name': m['name'], | |
| 'region': m['region'], | |
| 'level': m['level'], | |
| 'character': m.get('character', 'Unknown'), | |
| 'position': m['position'] | |
| } | |
| for m in new_members | |
| ] | |
| }) | |
| team_collection_active = True | |
| last_member_update = datetime.now() | |
| return True | |
| else: | |
| # No members found - bot left team | |
| if team_collection_active: | |
| print(f"[TEAM] ✗ Left team") | |
| # Broadcast team left | |
| broadcast_team_change('team_left', { | |
| 'in_team': False, | |
| 'total_members': 0, | |
| 'members': [] | |
| }) | |
| team_collection_active = False | |
| team_members_data.clear() | |
| previous_team_uids.clear() | |
| current_team_leader = None | |
| return False | |
| except: | |
| return False | |
| async def extract_complete_player_info(parsed_data, uid, position="Member"): | |
| """Extract player info - Better name detection""" | |
| try: | |
| player_info = { | |
| 'uid': str(uid), | |
| 'name': None, # Will be set below | |
| 'region': 'UNK', | |
| 'level': 0, | |
| 'position': position, | |
| 'character': 'Unknown', | |
| 'timestamp': datetime.now().isoformat() | |
| } | |
| def find_player_details(obj, target_uid, depth=0): | |
| if depth > 5: | |
| return None | |
| if isinstance(obj, dict): | |
| if ('1' in obj and obj['1'].get('data') == target_uid): | |
| details = {} | |
| if '2' in obj and isinstance(obj['2'].get('data'), str): | |
| name = obj['2']['data'] | |
| if name and len(name) > 1 and not name.isdigit(): | |
| details['name'] = name | |
| if '3' in obj and isinstance(obj['3'].get('data'), str): | |
| details['region'] = obj['3']['data'] | |
| if '5' in obj and isinstance(obj['5'].get('data'), int): | |
| details['level'] = obj['5']['data'] | |
| if '6' in obj and isinstance(obj['6'].get('data'), (int, str)): | |
| details['character'] = str(obj['6']['data']) | |
| return details | |
| for key, value in obj.items(): | |
| if isinstance(value, dict): | |
| result = find_player_details(value, target_uid, depth+1) | |
| if result: | |
| return result | |
| elif isinstance(value, list): | |
| for item in value: | |
| if isinstance(item, dict): | |
| result = find_player_details(item, target_uid, depth+1) | |
| if result: | |
| return result | |
| return None | |
| details = find_player_details(parsed_data, uid) | |
| if details: | |
| player_info.update(details) | |
| # If still no name found, use UID as fallback | |
| if not player_info['name']: | |
| player_info['name'] = f"Player_{uid}" | |
| return player_info | |
| except: | |
| return None | |
| async def deep_scan_for_players(data, path="", depth=0): | |
| """Scan for players""" | |
| players = [] | |
| if depth > 6: | |
| return players | |
| if isinstance(data, dict): | |
| if ('1' in data and '2' in data and | |
| isinstance(data['1'].get('data'), (int, str)) and | |
| isinstance(data['2'].get('data'), str)): | |
| uid = data['1']['data'] | |
| name = data['2']['data'] | |
| if (name and | |
| name != "Player_Unknown" and | |
| not name.startswith("Player_") and | |
| not name.isdigit() and | |
| len(name) > 1): | |
| player = { | |
| 'uid': str(uid), | |
| 'name': name, | |
| 'region': data['3']['data'] if '3' in data and isinstance(data['3'].get('data'), str) else 'UNK', | |
| 'level': data['5']['data'] if '5' in data and isinstance(data['5'].get('data'), int) else 0, | |
| 'character': str(data['6']['data']) if '6' in data and isinstance(data['6'].get('data'), (int, str)) else 'Unknown', | |
| 'position': 'Leader' if str(uid) == str(current_team_leader) else 'Member', | |
| 'timestamp': datetime.now().isoformat() | |
| } | |
| players.append(player) | |
| for key, value in data.items(): | |
| if isinstance(value, (dict, list)): | |
| nested_players = await deep_scan_for_players(value, f"{path}.{key}", depth+1) | |
| players.extend(nested_players) | |
| elif isinstance(data, list): | |
| for item in data: | |
| if isinstance(item, (dict, list)): | |
| nested_players = await deep_scan_for_players(item, f"{path}[]", depth+1) | |
| players.extend(nested_players) | |
| return players | |
| async def extract_from_field_structure_fixed(squad_data): | |
| """Extract from field structure""" | |
| players = [] | |
| try: | |
| if '6' in squad_data and 'data' in squad_data['6']: | |
| player_data = squad_data['6']['data'] | |
| if isinstance(player_data, dict) and '1' in player_data and '2' in player_data: | |
| uid = player_data['1'].get('data') | |
| name = player_data['2'].get('data') | |
| if uid and isinstance(name, str) and len(name) > 1 and not name.isdigit(): | |
| player = { | |
| 'uid': str(uid), | |
| 'name': name, | |
| 'region': player_data['3']['data'] if '3' in player_data and isinstance(player_data['3'].get('data'), str) else 'UNK', | |
| 'level': player_data['5']['data'] if '5' in player_data and isinstance(player_data['5'].get('data'), int) else 0, | |
| 'character': str(player_data['6']['data']) if '6' in player_data and isinstance(player_data['6'].get('data'), (int, str)) else 'Unknown', | |
| 'position': 'Leader' if str(uid) == str(current_team_leader) else 'Member', | |
| 'timestamp': datetime.now().isoformat() | |
| } | |
| players.append(player) | |
| for pos in ['1', '2', '3', '4', '7', '8']: | |
| if pos in squad_data and 'data' in squad_data[pos]: | |
| player_data = squad_data[pos]['data'] | |
| if isinstance(player_data, dict) and '1' in player_data and '2' in player_data: | |
| uid = player_data['1'].get('data') | |
| name = player_data['2'].get('data') | |
| if uid and isinstance(name, str) and len(name) > 1 and not name.isdigit(): | |
| player = { | |
| 'uid': str(uid), | |
| 'name': name, | |
| 'region': player_data['3']['data'] if '3' in player_data and isinstance(player_data['3'].get('data'), str) else 'UNK', | |
| 'level': player_data['5']['data'] if '5' in player_data and isinstance(player_data['5'].get('data'), int) else 0, | |
| 'character': str(player_data['6']['data']) if '6' in player_data and isinstance(player_data['6'].get('data'), (int, str)) else 'Unknown', | |
| 'position': 'Leader' if str(uid) == str(current_team_leader) else 'Member', | |
| 'timestamp': datetime.now().isoformat() | |
| } | |
| players.append(player) | |
| except: | |
| pass | |
| return players | |
| async def encrypted_proto(encoded_hex): | |
| key = b'Yg&tc%DEuh6%Zc^8' | |
| iv = b'6oyZDr22E3ychjM%' | |
| cipher = AES.new(key, AES.MODE_CBC, iv) | |
| padded_message = pad(encoded_hex, AES.block_size) | |
| encrypted_payload = cipher.encrypt(padded_message) | |
| return encrypted_payload | |
| async def GeNeRaTeAccEss(uid , password): | |
| url = "https://100067.connect.garena.com/oauth/guest/token/grant" | |
| headers = { | |
| "Host": "100067.connect.garena.com", | |
| "User-Agent": (await Ua()), | |
| "Content-Type": "application/x-www-form-urlencoded", | |
| "Accept-Encoding": "gzip, deflate, br", | |
| "Connection": "close"} | |
| data = { | |
| "uid": uid, | |
| "password": password, | |
| "response_type": "token", | |
| "client_type": "2", | |
| "client_secret": "2ee44819e9b4598845141067b281621874d0d5d7af9d8f7e00c1e54715b7d1e3", | |
| "client_id": "100067"} | |
| async with aiohttp.ClientSession() as session: | |
| async with session.post(url, headers=Hr, data=data) as response: | |
| if response.status != 200: return "Failed to get access token" | |
| data = await response.json() | |
| open_id = data.get("open_id") | |
| access_token = data.get("access_token") | |
| return (open_id, access_token) if open_id and access_token else (None, None) | |
| async def EncRypTMajoRLoGin(open_id, access_token): | |
| major_login = MajoRLoGinrEq_pb2.MajorLogin() | |
| major_login.event_time = str(datetime.now())[:-7] | |
| major_login.game_name = "free fire" | |
| major_login.platform_id = 1 | |
| major_login.client_version = "1.120.2" | |
| major_login.system_software = "Android OS 9 / API-28 (PQ3B.190801.10101846/G9650ZHU2ARC6)" | |
| major_login.system_hardware = "Handheld" | |
| major_login.telecom_operator = "Verizon" | |
| major_login.network_type = "WIFI" | |
| major_login.screen_width = 1920 | |
| major_login.screen_height = 1080 | |
| major_login.screen_dpi = "280" | |
| major_login.processor_details = "ARM64 FP ASIMD AES VMH | 2865 | 4" | |
| major_login.memory = 3003 | |
| major_login.gpu_renderer = "Adreno (TM) 640" | |
| major_login.gpu_version = "OpenGL ES 3.1 v1.46" | |
| major_login.unique_device_id = "Google|34a7dcdf-a7d5-4cb6-8d7e-3b0e448a0c57" | |
| major_login.client_ip = "223.191.51.89" | |
| major_login.language = "en" | |
| major_login.open_id = open_id | |
| major_login.open_id_type = "4" | |
| major_login.device_type = "Handheld" | |
| memory_available = major_login.memory_available | |
| memory_available.version = 55 | |
| memory_available.hidden_value = 81 | |
| major_login.access_token = access_token | |
| major_login.platform_sdk_id = 1 | |
| major_login.network_operator_a = "Verizon" | |
| major_login.network_type_a = "WIFI" | |
| major_login.client_using_version = "7428b253defc164018c604a1ebbfebdf" | |
| major_login.external_storage_total = 36235 | |
| major_login.external_storage_available = 31335 | |
| major_login.internal_storage_total = 2519 | |
| major_login.internal_storage_available = 703 | |
| major_login.game_disk_storage_available = 25010 | |
| major_login.game_disk_storage_total = 26628 | |
| major_login.external_sdcard_avail_storage = 32992 | |
| major_login.external_sdcard_total_storage = 36235 | |
| major_login.login_by = 3 | |
| major_login.library_path = "/data/app/com.dts.freefireth-YPKM8jHEwAJlhpmhDhv5MQ==/lib/arm64" | |
| major_login.reg_avatar = 1 | |
| major_login.library_token = "5b892aaabd688e571f688053118a162b|/data/app/com.dts.freefireth-YPKM8jHEwAJlhpmhDhv5MQ==/base.apk" | |
| major_login.channel_type = 3 | |
| major_login.cpu_type = 2 | |
| major_login.cpu_architecture = "64" | |
| major_login.client_version_code = "2019116753" | |
| major_login.graphics_api = "OpenGLES2" | |
| major_login.supported_astc_bitset = 16383 | |
| major_login.login_open_id_type = 4 | |
| major_login.analytics_detail = b"FwQVTgUPX1UaUllDDwcWCRBpWAUOUgsvA1snWlBaO1kFYg==" | |
| major_login.loading_time = 13564 | |
| major_login.release_channel = "android" | |
| major_login.extra_info = "KqsHTymw5/5GB23YGniUYN2/q47GATrq7eFeRatf0NkwLKEMQ0PK5BKEk72dPflAxUlEBir6Vtey83XqF593qsl8hwY=" | |
| major_login.android_engine_init_flag = 110009 | |
| major_login.if_push = 1 | |
| major_login.is_vpn = 1 | |
| major_login.origin_platform_type = "4" | |
| major_login.primary_platform_type = "4" | |
| string = major_login.SerializeToString() | |
| return await encrypted_proto(string) | |
| async def MajorLogin(payload): | |
| url = "https://loginbp.ggblueshark.com/MajorLogin" | |
| ssl_context = ssl.create_default_context() | |
| ssl_context.check_hostname = False | |
| ssl_context.verify_mode = ssl.CERT_NONE | |
| async with aiohttp.ClientSession() as session: | |
| async with session.post(url, data=payload, headers=Hr, ssl=ssl_context) as response: | |
| if response.status == 200: return await response.read() | |
| return None | |
| async def GetLoginData(base_url, payload, token): | |
| url = f"{base_url}/GetLoginData" | |
| ssl_context = ssl.create_default_context() | |
| ssl_context.check_hostname = False | |
| ssl_context.verify_mode = ssl.CERT_NONE | |
| Hr['Authorization']= f"Bearer {token}" | |
| async with aiohttp.ClientSession() as session: | |
| async with session.post(url, data=payload, headers=Hr, ssl=ssl_context) as response: | |
| if response.status == 200: return await response.read() | |
| return None | |
| async def DecRypTMajoRLoGin(MajoRLoGinResPonsE): | |
| proto = MajoRLoGinrEs_pb2.MajorLoginRes() | |
| proto.ParseFromString(MajoRLoGinResPonsE) | |
| return proto | |
| async def DecRypTLoGinDaTa(LoGinDaTa): | |
| proto = PorTs_pb2.GetLoginData() | |
| proto.ParseFromString(LoGinDaTa) | |
| return proto | |
| async def DecodeWhisperMessage(hex_packet): | |
| packet = bytes.fromhex(hex_packet) | |
| proto = DEcwHisPErMsG_pb2.DecodeWhisper() | |
| proto.ParseFromString(packet) | |
| return proto | |
| async def decode_team_packet(hex_packet): | |
| packet = bytes.fromhex(hex_packet) | |
| proto = sQ_pb2.recieved_chat() | |
| proto.ParseFromString(packet) | |
| return proto | |
| async def xAuThSTarTuP(TarGeT, token, timestamp, key, iv): | |
| uid_hex = hex(TarGeT)[2:] | |
| uid_length = len(uid_hex) | |
| encrypted_timestamp = await DecodE_HeX(timestamp) | |
| encrypted_account_token = token.encode().hex() | |
| encrypted_packet = await EnC_PacKeT(encrypted_account_token, key, iv) | |
| encrypted_packet_length = hex(len(encrypted_packet) // 2)[2:] | |
| if uid_length == 9: headers = '0000000' | |
| elif uid_length == 8: headers = '00000000' | |
| elif uid_length == 10: headers = '000000' | |
| elif uid_length == 7: headers = '000000000' | |
| else: print('Unexpected length') ; headers = '0000000' | |
| return f"0115{headers}{uid_hex}{encrypted_timestamp}00000{encrypted_packet_length}{encrypted_packet}" | |
| async def cHTypE(H): | |
| if not H: return 'Squid' | |
| elif H == 1: return 'CLan' | |
| elif H == 2: return 'PrivaTe' | |
| async def SEndMsG(H , message , Uid , chat_id , key , iv): | |
| TypE = await cHTypE(H) | |
| if TypE == 'Squid': msg_packet = await xSEndMsgsQ(message , chat_id , key , iv) | |
| elif TypE == 'CLan': msg_packet = await xSEndMsg(message , 1 , chat_id , chat_id , key , iv) | |
| elif TypE == 'PrivaTe': msg_packet = await xSEndMsg(message , 2 , Uid , Uid , key , iv) | |
| return msg_packet | |
| async def SEndPacKeT(OnLinE , ChaT , TypE , PacKeT): | |
| if TypE == 'ChaT' and ChaT: whisper_writer.write(PacKeT) ; await whisper_writer.drain() | |
| elif TypE == 'OnLine': online_writer.write(PacKeT) ; await online_writer.drain() | |
| else: return 'UnsoPorTed TypE ! >> ErrrroR (:():)' | |
| async def TcPOnLine(ip, port, key_val, iv_val, AutHToKen, reconnect_delay=0.5): | |
| global online_writer, key, iv, team_members_data, current_team_leader | |
| global team_collection_active, previous_team_uids | |
| key = key_val | |
| iv = iv_val | |
| while True: | |
| try: | |
| # Reset team state on new connection | |
| team_members_data = [] | |
| current_team_leader = None | |
| team_collection_active = False | |
| previous_team_uids = set() | |
| reader, writer = await asyncio.open_connection(ip, int(port)) | |
| online_writer = writer | |
| print(f"[ONLINE] Connected to {ip}:{port}") | |
| bytes_payload = bytes.fromhex(AutHToKen) | |
| online_writer.write(bytes_payload) | |
| await online_writer.drain() | |
| while True: | |
| data2 = await reader.read(9999) | |
| if not data2: break | |
| packet_hex = data2.hex() | |
| # Team collection | |
| if packet_hex.startswith('0500') and len(packet_hex) > 1000: | |
| try: | |
| decoded = await DeCode_PackEt(packet_hex[10:]) | |
| parsed = json.loads(decoded) | |
| await collect_team_members_dynamic('0500_LARGE', parsed) | |
| except: | |
| pass | |
| # Your existing chat code | |
| if data2.hex().startswith('0500') and len(data2.hex()) > 1000: | |
| try: | |
| packet = await DeCode_PackEt(data2.hex()[10:]) | |
| packet = json.loads(packet) | |
| OwNer_UiD, CHaT_CoDe, SQuAD_CoDe = await GeTSQDaTa(packet) | |
| JoinCHaT = await AutH_Chat(3, OwNer_UiD, CHaT_CoDe, key, iv) | |
| await SEndPacKeT(whisper_writer, online_writer, 'ChaT', JoinCHaT) | |
| except: | |
| pass | |
| online_writer.close() | |
| await online_writer.wait_closed() | |
| online_writer = None | |
| # Broadcast disconnect | |
| if team_collection_active: | |
| print(f"[TEAM] ✗ Disconnected from team") | |
| broadcast_team_change('team_left', { | |
| 'in_team': False, | |
| 'total_members': 0, | |
| 'members': [] | |
| }) | |
| # Reset state on disconnect | |
| team_members_data = [] | |
| current_team_leader = None | |
| team_collection_active = False | |
| previous_team_uids = set() | |
| except Exception as e: | |
| print(f"[ERROR] {ip}:{port} - {e}") | |
| online_writer = None | |
| # Reset state on error | |
| team_members_data = [] | |
| current_team_leader = None | |
| team_collection_active = False | |
| previous_team_uids = set() | |
| await asyncio.sleep(reconnect_delay) | |
| async def TcPChaT(ip, port, AutHToKen, key_val, iv_val, LoGinDaTaUncRypTinG, ready_event, region_val, reconnect_delay=0.5): | |
| global spam_room, whisper_writer, spammer_uid, spam_chat_id, spam_uid, online_writer, chat_id, XX, uid, Spy, data2, Chat_Leave | |
| global region # API access के लिए | |
| # Update global variables for API | |
| region = region_val | |
| print(region, 'TCP CHAT') | |
| while True: | |
| try: | |
| reader, writer = await asyncio.open_connection(ip, int(port)) | |
| whisper_writer = writer | |
| print(f"[CHAT] Connected to {ip}:{port}") # Debug message | |
| bytes_payload = bytes.fromhex(AutHToKen) | |
| whisper_writer.write(bytes_payload) | |
| await whisper_writer.drain() | |
| ready_event.set() | |
| if LoGinDaTaUncRypTinG.Clan_ID: | |
| clan_id = LoGinDaTaUncRypTinG.Clan_ID | |
| clan_compiled_data = LoGinDaTaUncRypTinG.Clan_Compiled_Data | |
| print('\n - TarGeT BoT in CLan ! ') | |
| print(f' - Clan Uid > {clan_id}') | |
| print(f' - BoT ConnEcTed WiTh CLan ChaT SuccEssFuLy ! ') | |
| pK = await AuthClan(clan_id, clan_compiled_data, key_val, iv_val) | |
| if whisper_writer: | |
| whisper_writer.write(pK) | |
| await whisper_writer.drain() | |
| while True: | |
| data = await reader.read(9999) | |
| if not data: break | |
| if data.hex().startswith("120000"): | |
| msg = await DeCode_PackEt(data.hex()[10:]) | |
| chatdata = json.loads(msg) | |
| try: | |
| response = await DecodeWhisperMessage(data.hex()[10:]) | |
| uid = response.Data.uid | |
| chat_id = response.Data.Chat_ID | |
| XX = response.Data.chat_type | |
| inPuTMsG = response.Data.msg.lower() | |
| except: | |
| response = None | |
| if response: | |
| if inPuTMsG.startswith(("/5")): | |
| try: | |
| dd = chatdata['5']['data']['16'] | |
| print('msg in private') | |
| message = f"[B][C]{get_random_color()}\n\nAccepT My Invitation FasT\n\n" | |
| P = await SEndMsG(response.Data.chat_type, message, uid, chat_id, key_val, iv_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'ChaT', P) | |
| PAc = await OpEnSq(key_val, iv_val, region_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', PAc) | |
| C = await cHSq(5, uid, key_val, iv_val, region_val) | |
| await asyncio.sleep(0.5) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', C) | |
| V = await SEnd_InV(5, uid, key_val, iv_val, region_val) | |
| await asyncio.sleep(0.5) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', V) | |
| E = await ExiT(None, key_val, iv_val) | |
| await asyncio.sleep(3) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', E) | |
| except: | |
| print('msg in squad') | |
| if inPuTMsG.startswith('/x/'): | |
| CodE = inPuTMsG.split('/x/')[1] | |
| try: | |
| dd = chatdata['5']['data']['16'] | |
| print('msg in private') | |
| EM = await GenJoinSquadsPacket(CodE, key_val, iv_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', EM) | |
| except: | |
| print('msg in squad') | |
| if inPuTMsG.startswith('/solo'): | |
| leave = await ExiT(uid, key_val, iv_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', leave) | |
| if inPuTMsG.strip().startswith('/s'): | |
| EM = await FS(key_val, iv_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', EM) | |
| if inPuTMsG.strip().startswith('!e'): | |
| try: | |
| dd = chatdata['5']['data']['16'] | |
| print('msg in private') | |
| message = f"[B][C]{get_random_color()}\n\nCommand Available OnLy In SQuaD ! \n\n" | |
| P = await SEndMsG(response.Data.chat_type, message, uid, chat_id, key_val, iv_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'ChaT', P) | |
| except: | |
| print('msg in squad') | |
| parts = inPuTMsG.strip().split() | |
| print(response.Data.chat_type, uid, chat_id) | |
| message = f'[B][C]{get_random_color()}\nACITVE TarGeT -> {xMsGFixinG(uid)}\n' | |
| P = await SEndMsG(response.Data.chat_type, message, uid, chat_id, key_val, iv_val) | |
| uid2 = uid3 = uid4 = uid5 = None | |
| s = False | |
| try: | |
| uid = int(parts[1]) | |
| uid2 = int(parts[2]) | |
| uid3 = int(parts[3]) | |
| uid4 = int(parts[4]) | |
| uid5 = int(parts[5]) | |
| idT = int(parts[5]) | |
| except ValueError as ve: | |
| print("ValueError:", ve) | |
| s = True | |
| except Exception: | |
| idT = len(parts) - 1 | |
| idT = int(parts[idT]) | |
| print(idT) | |
| print(uid) | |
| if not s: | |
| try: | |
| await SEndPacKeT(whisper_writer, online_writer, 'ChaT', P) | |
| H = await Emote_k(uid, idT, key_val, iv_val, region_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', H) | |
| if uid2: | |
| H = await Emote_k(uid2, idT, key_val, iv_val, region_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', H) | |
| if uid3: | |
| H = await Emote_k(uid3, idT, key_val, iv_val, region_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', H) | |
| if uid4: | |
| H = await Emote_k(uid4, idT, key_val, iv_val, region_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', H) | |
| if uid5: | |
| H = await Emote_k(uid5, idT, key_val, iv_val, region_val) | |
| await SEndPacKeT(whisper_writer, online_writer, 'OnLine', H) | |
| except Exception as e: | |
| pass | |
| whisper_writer.close() | |
| await whisper_writer.wait_closed() | |
| whisper_writer = None | |
| except Exception as e: | |
| print(f"ErroR {ip}:{port} - {e}") | |
| whisper_writer = None | |
| await asyncio.sleep(reconnect_delay) | |
| async def MaiiiinE(): | |
| Uid, Pw = '4564739053','C4699623713B6085801ED5460693D5AF866299004250E4C7F015C46EF879C639' | |
| open_id, access_token = await GeNeRaTeAccEss(Uid, Pw) | |
| if not open_id or not access_token: | |
| print("ErroR - InvaLid AccounT") | |
| return None | |
| PyL = await EncRypTMajoRLoGin(open_id, access_token) | |
| MajoRLoGinResPonsE = await MajorLogin(PyL) | |
| if not MajoRLoGinResPonsE: | |
| print("TarGeT AccounT => BannEd / NoT ReGisTeReD ! ") | |
| return None | |
| MajoRLoGinauTh = await DecRypTMajoRLoGin(MajoRLoGinResPonsE) | |
| UrL = MajoRLoGinauTh.url | |
| print(UrL) | |
| region_val = MajoRLoGinauTh.region | |
| ToKen = MajoRLoGinauTh.token | |
| TarGeT = MajoRLoGinauTh.account_uid | |
| key_val = MajoRLoGinauTh.key | |
| iv_val = MajoRLoGinauTh.iv | |
| timestamp = MajoRLoGinauTh.timestamp | |
| LoGinDaTa = await GetLoginData(UrL, PyL, ToKen) | |
| if not LoGinDaTa: | |
| print("ErroR - GeTinG PorTs From LoGin DaTa !") | |
| return None | |
| LoGinDaTaUncRypTinG = await DecRypTLoGinDaTa(LoGinDaTa) | |
| OnLinePorTs = LoGinDaTaUncRypTinG.Online_IP_Port | |
| ChaTPorTs = LoGinDaTaUncRypTinG.AccountIP_Port | |
| OnLineiP, OnLineporT = OnLinePorTs.split(":") | |
| ChaTiP, ChaTporT = ChaTPorTs.split(":") | |
| acc_name = LoGinDaTaUncRypTinG.AccountName | |
| print(ToKen) | |
| equie_emote(ToKen, UrL) | |
| AutHToKen = await xAuThSTarTuP(int(TarGeT), ToKen, int(timestamp), key_val, iv_val) | |
| ready_event = asyncio.Event() | |
| task1 = asyncio.create_task(TcPChaT(ChaTiP, ChaTporT, AutHToKen, key_val, iv_val, LoGinDaTaUncRypTinG, ready_event, region_val)) | |
| await ready_event.wait() | |
| await asyncio.sleep(1) | |
| task2 = asyncio.create_task(TcPOnLine(OnLineiP, OnLineporT, key_val, iv_val, AutHToKen)) | |
| os.system('clear') | |
| print(render('WINTER', colors=['white', 'green'], align='center')) | |
| print('') | |
| print(f" - BoT STarTinG And OnLine on TarGet : {TarGeT} | BOT NAME : {acc_name}\n") | |
| print(f" - BoT sTaTus > GooD | OnLinE ! (:") | |
| print(f" - Subscribe > MatrixCoder | Gaming ! (:") | |
| await asyncio.gather(task1, task2) | |
| async def StarTinG(): | |
| while True: | |
| try: | |
| await asyncio.wait_for(MaiiiinE(), timeout=7 * 60 * 60) | |
| except asyncio.TimeoutError: | |
| print("Token ExpiRed ! , ResTartinG") | |
| except Exception as e: | |
| print(f"ErroR TcP - {e} => ResTarTinG ...") | |
| if __name__ == '__main__': | |
| asyncio.run(StarTinG()) |