redzedbot 1.0.0__py3-none-any.whl

redzedbot/__init__.py

@@ -0,0 +1,9 @@
+"""
+redzedbot - Async Free Fire Bot Library
+"""
+
+from .client import redzedbot
+from .guest import login
+
+__version__ = "5.0.0"
+__all__ = ["redzedbot", "login"]

redzedbot/auth.py

@@ -0,0 +1,248 @@
+"""
+Authentication and login handling
+"""
+
+import asyncio
+import aiohttp
+import json
+import ssl
+from typing import Dict, Optional, Tuple
+from datetime import datetime
+from .proto import ParaHex_pb2
+from .utils import get_random_user_agent, encrypt_proto
+from .config import Config
+
+
+async def generate_access_token(uid: str, password: str) -> Tuple[Optional[str], Optional[str]]:
+    """Generate Garena access token"""
+    url = "https://100067.connect.garena.com/oauth/guest/token/grant"
+    
+    headers = {
+        "Host": "100067.connect.garena.com",
+        "User-Agent": await get_random_user_agent(),
+        "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"
+    }
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, headers=headers, data=data) as response:
+                if response.status != 200:
+                    return None, None
+                
+                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)
+                
+    except Exception as e:
+        print(f"Token generation error: {e}")
+        return None, None
+
+
+async def create_payload(open_id: str, access_token: str) -> bytes:
+    """Create encrypted protobuf payload for login"""
+    major_login = ParaHex_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 = Config.VERSION
+    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 = "2019118695"
+    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 encrypt_proto(string)
+
+
+async def major_login(open_id: str, access_token: str) -> Optional[bytes]:
+    """Perform major login"""
+    if not Config._updated:
+        await Config.auto_update()
+    
+    payload = await create_payload(open_id, access_token)
+    url = f"{Config.LOGIN_URL}MajorLogin"
+    
+    headers = {
+        'User-Agent': await get_random_user_agent(),
+        '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': Config.OB
+    }
+    
+    ssl_context = ssl.create_default_context()
+    ssl_context.check_hostname = False
+    ssl_context.verify_mode = ssl.CERT_NONE
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, data=payload, headers=headers, ssl=ssl_context) as response:
+                response_content = await response.read()
+                if response.status == 200:
+                    return response_content
+                return None
+    except Exception as e:
+        print(f"Major login error: {e}")
+        return None
+
+
+async def get_login_data(major_response: bytes, open_id: str, access_token: str) -> Optional[Dict]:
+    """Get login data from major login response"""
+    try:
+        proto = ParaHex_pb2.MajorLoginRes()
+        proto.ParseFromString(major_response)
+        
+        clientbp = proto.url
+        token = proto.token
+        account_uid = proto.account_uid
+        timestamp = proto.timestamp
+        key = proto.key
+        iv = proto.iv
+        
+        payload = await create_payload(open_id, access_token)
+        login_url = f"{clientbp}/GetLoginData"
+        
+        headers = {
+            'User-Agent': await get_random_user_agent(),
+            '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': Config.OB,
+            'Authorization': f"Bearer {token}"
+        }
+        
+        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(login_url, data=payload, headers=headers, ssl=ssl_context) as response:
+                if response.status != 200:
+                    return None
+                
+                response_data = await response.read()
+                
+                proto = ParaHex_pb2.GetLoginData()
+                proto.ParseFromString(response_data)
+                
+                online_ports = proto.Online_IP_Port
+                chat_ports = proto.AccountIP_Port
+                online_ip, online_port = online_ports.split(":")
+                chat_ip, chat_port = chat_ports.split(":")
+                
+                return {
+                    'account_uid': account_uid,
+                    'nickname': proto.AccountName,
+                    'region': proto.Region,
+                    'online_ip': online_ip,
+                    'online_port': online_port,
+                    'chat_ip': chat_ip,
+                    'chat_port': chat_port,
+                    'clan_id': proto.Clan_ID if proto.Clan_ID else None,
+                    'token': token,
+                    'timestamp': timestamp,
+                    'key': key,
+                    'iv': iv,
+                    'url':clientbp
+                    
+                }
+                
+    except Exception as e:
+        print(f"Login data error: {e}")
+        return None
+
+
+async def create_auth_packet(account_uid: int, token: str, timestamp: int, key: bytes, iv: bytes) -> str:
+    """Create authentication packet"""
+    from .utils import encode_hex, encrypt_packet
+    
+    uid_hex = hex(account_uid)[2:]
+    uid_length = len(uid_hex)
+    encrypted_timestamp = await encode_hex(timestamp)
+    encrypted_account_token = token.encode().hex()
+    encrypted_packet = await encrypt_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:
+        headers = '0000000'
+    
+    return f"0115{headers}{uid_hex}{encrypted_timestamp}00000{encrypted_packet_length}{encrypted_packet}"

redzedbot/client.py

@@ -0,0 +1,326 @@
+"""
+Main redzedbot client class
+"""
+
+import asyncio
+from typing import Callable, Dict, Optional, Any
+from .auth import generate_access_token, major_login, get_login_data, create_auth_packet
+from .connection import OnlineConnection, ChatConnection
+from .message import Message
+from .utils import get_random_user_agent
+import requests
+from .config import Config
+from .utils import create_proto,E_AEs
+
+class redzedbot:
+    """
+    Main bot client class with decorator-based event handling
+    """
+    
+    def __init__(self, uid: str, password: str):
+        self.uid = uid
+        self.password = password
+        
+        self.is_connected = False
+        self.chat_connected = False
+        self.online_connected = False
+        
+        self.nickname = None
+        self.account_uid = None
+        self.region = None
+        self.clan_id = None
+        
+        self._key = None
+        self._iv = None
+        self._token = None
+        self._timestamp = None
+        self._auth_packet = None
+        
+        self._online_conn = None
+        self._chat_conn = None
+        
+        self._message_handlers = []
+        self._ready_handlers = []
+        
+        self._ready_event = asyncio.Event()
+    
+    async def _authenticate(self) -> bool:
+        """Internal authentication process"""
+        try:
+            from .config import Config
+            if not Config._updated:
+
+                await Config.auto_update()
+                
+            
+            open_id, access_token = await generate_access_token(self.uid, self.password)
+            if not open_id or not access_token:
+                return False
+            
+            print(f'LoginURL : {Config.LOGIN_URL}MajorLogin , Version {Config.VERSION} , OB: {Config.OB}')
+            major_response = await major_login(open_id, access_token)
+            if not major_response:
+                return False
+            
+            login_data = await get_login_data(major_response, open_id, access_token)
+            if not login_data:
+                return False
+            
+            self.account_uid = login_data['account_uid']
+            self.nickname = login_data['nickname']
+            self.region = login_data['region']
+            self.clan_id = login_data.get('clan_id')
+            self._clientbp = login_data['url']
+            self._key = login_data['key']
+            self._iv = login_data['iv']
+            self._token = login_data['token']
+            self._timestamp = login_data['timestamp']
+            self._online_conn = OnlineConnection(
+                login_data['online_ip'],
+                login_data['online_port'],
+                self._key,
+                self._iv
+            )
+            
+            self._chat_conn = ChatConnection(
+                login_data['chat_ip'],
+                login_data['chat_port'],
+                self._key,
+                self._iv,
+                self._process_message
+            )
+            
+            self._auth_packet = await create_auth_packet(
+                self.account_uid,
+                self._token,
+                self._timestamp,
+                self._key,
+                self._iv
+            )
+            
+            self.is_connected = True
+            return True
+            
+        except Exception as e:
+            print(f"Authentication error: {e}")
+            return False
+        
+
+
+    async def add_friend(self, uid: int):
+        """
+        Add Friend Via UID.
+
+        Example:
+            await bot.add_friend(6728454010)
+        """
+
+
+        try:
+            user_id = int(uid)
+        except ValueError:
+            return "Only Uid In Numbers :/"
+
+        
+        if not self._online_conn:
+            return "online connection not correctly started"
+
+        url = self._clientbp + "/RequestAddingFriend"
+
+        fields = {
+            1: self.account_uid,
+            2: user_id,
+            3: 22
+        }
+
+        proto = await create_proto(fields)
+        pphex = proto.hex()
+        encrypted_payload = await E_AEs(pphex)
+
+
+        headers = {
+            "Accept-Encoding": "gzip",
+            "Authorization": f"Bearer {self._token}",
+            "Connection": "Keep-Alive",
+            "Content-Type": "application/octet-stream",
+            "Expect": "100-continue",
+            "Host": Config.HOST,
+            "ReleaseVersion": Config.OB,
+            "User-Agent": "Dalvik/2.1.0 (Linux; U; Android 9; ASUS_I005DA Build/PI)",
+            "X-GA": "v1 1",
+            "X-Unity-Version": "2018.4.11f1"
+        }
+
+        response = requests.post(
+            url,
+            headers=headers,
+            data=encrypted_payload,
+            verify=False,
+        )
+
+        print(response.text)
+
+        if "BR_FRIEND_ALREADY_SENT_REQUEST" in response.text:
+            return "Already Sent The Friend Request"
+        elif "BR_FRIEND_DUPLICATE" in response.text:
+            return "User Is Already A Friend"
+        else:
+            return "Sent Invite!"
+
+
+        
+        
+
+
+    
+    def message_handler(self, command: Optional[str] = None):
+        """
+        Decorator for message handlers.
+        
+        Args:
+            command: Optional command to match (e.g., 'Hi', 'help')
+        
+        Example:
+            @bot.message_handler(command='Hi')
+            async def handle_hi(msg):
+                await bot.send_dm('Hello!', msg.user_id)
+        """
+        def decorator(func: Callable):
+            self._message_handlers.append({
+                'command': command.lower() if command else None,
+                'handler': func
+            })
+            return func
+        return decorator
+    
+    def online(self):
+        """
+        Decorator for ready/online event handler.
+        
+        Example:
+            @bot.online()
+            def on_ready(bot):
+                if bot.is_connected:
+                    print(f"Logged in as {bot.nickname}")
+        """
+        def decorator(func: Callable):
+            self._ready_handlers.append(func)
+            return func
+        return decorator
+    
+    async def _process_message(self, msg_data: Dict[str, Any]):
+        """Internal message processor"""
+        try:
+            msg = Message(msg_data)
+            
+            for handler_info in self._message_handlers:
+                command = handler_info['command']
+                handler = handler_info['handler']
+                
+                if command is None or msg.text.lower().startswith(command):
+                    if asyncio.iscoroutinefunction(handler):
+                        await handler(msg)
+                    else:
+                        handler(msg)
+                        
+        except Exception as e:
+            print(f"Message processing error: {e}")
+    
+    async def _trigger_ready_handlers(self):
+        """Trigger all ready handlers"""
+        for handler in self._ready_handlers:
+            try:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(self)
+                else:
+                    handler(self)
+            except Exception as e:
+                print(f"Ready handler error: {e}")
+    
+    async def send_dm(self, message: str, user_id: int):
+        """
+        Send a direct message to a user.
+        
+        Args:
+            message: Message text
+            user_id: Target user ID
+        """
+
+        if not self._chat_conn:
+            print("Chat connection not correctly started")
+            return
+        
+        await self._chat_conn.send_dm(message, user_id, self._key, self._iv)
+    
+    async def send_squad(self, message: str, chat_id: int):
+        """
+        Send a message to squad chat.
+        
+        Args:
+            message: Message text
+            chat_id: Squad chat ID
+        """
+        if not self._chat_conn:
+            print("Chat connection not established")
+            return
+        
+        await self._chat_conn.send_squad(message, chat_id, self._key, self._iv)
+    
+    async def send_guild(self, message: str, chat_id: int):
+        """
+        Send a message to guild chat.
+        
+        Args:
+            message: Message text
+            chat_id: Guild chat ID
+        """
+        if not self._chat_conn:
+            print("Chat connection not established")
+            return
+        
+        await self._chat_conn.send_guild(message, chat_id, self._key, self._iv)
+    
+    async def online_loop(self):
+        """
+        Main event loop - keeps the bot online and processing messages.
+        This is a blocking call that runs until interrupted.
+        
+        Example:
+            await bot.online_loop()
+        """
+        try:
+            online_task = asyncio.create_task(
+                self._online_conn.connect(self._auth_packet)
+            )
+            
+            chat_task = asyncio.create_task(
+                self._chat_conn.connect(self._auth_packet)
+            )
+            
+            await asyncio.sleep(1)
+            
+            self.online_connected = self._online_conn.is_connected
+            self.chat_connected = self._chat_conn.is_connected
+            
+            await self._trigger_ready_handlers()
+            
+            await asyncio.gather(online_task, chat_task)
+            
+        except KeyboardInterrupt:
+            print("\nBot stopped by user")
+        except Exception as e:
+            print(f"Event loop error: {e}")
+        finally:
+            await self.disconnect()
+    
+    async def disconnect(self):
+        """Disconnect all connections"""
+        if self._online_conn:
+            await self._online_conn.close()
+        await asyncio.sleep(0.5)
+        if self._chat_conn:
+            await self._chat_conn.close()
+        
+        self.is_connected = False
+        self.chat_connected = False
+        self.online_connected = False

redzedbot/config.py

@@ -0,0 +1,53 @@
+"""
+Configuration module - Auto-updates from Google Play Store
+"""
+
+import asyncio
+import aiohttp
+import json
+from google_play_scraper import app
+
+
+class Config:
+    """Configuration settings - Auto-updated on first use"""
+    
+    LOGIN_URL = None
+    OB = None
+    VERSION = None
+    HOST = None
+    
+    AES_KEY = b'Yg&tc%DEuh6%Zc^8'
+    AES_IV = b'6oyZDr22E3ychjM%'
+    
+    _updated = False
+    
+    @classmethod
+    async def auto_update(cls):
+        """Auto-update configuration from game version"""
+        if cls._updated:
+            return True
+            
+        try:
+            result = app('com.dts.freefireth', lang="fr", country='fr')
+            version = result['version']
+            
+            url = f'https://bdversion.ggbluefox.com/live/ver.php?version={version}&lang=ar&device=android&channel=android&appstore=googleplay&region=ME&whitelist_version=1.3.0&whitelist_sp_version=1.0.0&device_name=google%20G011A&device_CPU=ARMv7%20VFPv3%20NEON%20VMH&device_GPU=Adreno%20(TM)%20640&device_mem=1993'
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url) as res:
+                    text = await res.text()
+                    data = json.loads(text)
+            
+            cls.LOGIN_URL = data['server_url']
+            cls.OB = data['latest_release_version']
+            cls.VERSION = version
+            cls.HOST = data['server_url'].split('//')[1].split('/')[0]
+            
+            cls._updated = True
+            return True
+            
+        except Exception as e:
+            print(f"⚠️  Auto-update failed: {e}")
+            print("Using fallback configuration...")
+   
+            return False