src/classes/baseprocessor.py

@@ -1,47 +0,0 @@
-import logging
-from common.config import ServerConfig
-from common.static import Static
-from common.tools import Tools
-from common.proto_tcp import MobileProto
-from common.proto_web import WebProto
-from common.opcodes import Opcodes
-
-class BaseProcessor:
-    def __init__(self, db_pool=None, clients=None, send_event=None, type="socket"):
-        if clients is None:
-            clients = {}
-        self.config = ServerConfig()
-        self.static = Static()
-        self.tools = Tools()
-        self.opcodes = Opcodes()
-        self.error_types = self.static.ErrorTypes()
-
-        self.db_pool = db_pool
-        self.clients = clients
-        self.send_event = send_event
-        self.logger = logging.getLogger(__name__)
-
-        if type == "socket":
-            self.proto = MobileProto()
-        elif type == "web":
-            self.proto = WebProto()
-
-    async def _send(self, writer, packet):
-        try:
-            writer.write(packet)
-            await writer.drain()
-        except Exception:
-            pass
-
-    async def _send_error(self, seq, opcode, error_type, writer):
-        payload = self.static.ERROR_TYPES.get(error_type, {
-            "localizedMessage": "Неизвестная ошибка",
-            "error": "unknown.error",
-            "message": "Unknown error",
-            "title": "Неизвестная ошибка"
-        })
-
-        packet = self.proto.pack_packet(
-            cmd=self.proto.CMD_ERR, seq=seq, opcode=opcode, payload=payload
-        )
-        await self._send(writer, packet)

src/common/static.py

@@ -176,23 +176,3 @@ class Static:
         "M_CALL_PUSH_NOTIFICATION": "ON",
         "QUICK_REPLY": False
     }
-
-    ### Коды стран, которым разрешён вход
-    REG_COUNTRY_CODES = ['AD', 'AE', 'AF', 'AG', 'AI', 'AL', 'AM', 'AO', 'AQ', 'AR', 'AS', 'AT', 'AU', 'AW', 
-                         'AX', 'AZ', 'BA', 'BB', 'BD', 'BE', 'BF', 'BG', 'BH', 'BI', 'BJ', 'BL', 'BM', 'BN', 
-                         'BO', 'BR', 'BS', 'BT', 'BW', 'BY', 'BZ', 'CA', 'CC', 'CD', 'CF', 'CG', 'CH', 'CI', 
-                         'CK', 'CL', 'CM', 'CN', 'CO', 'CR', 'CU', 'CV', 'CW', 'CX', 'CY', 'CZ', 'DE', 'DJ', 
-                         'DK', 'DM', 'DO', 'DZ', 'EC', 'EE', 'EG', 'ER', 'ES', 'ET', 'FI', 'FJ', 'FK', 'FM', 
-                         'FO', 'FR', 'GA', 'GB', 'GD', 'GE', 'GF', 'GG', 'GH', 'GI', 'GL', 'GM', 'GN', 'GP', 
-                         'GQ', 'GR', 'GT', 'GU', 'GW', 'GY', 'HK', 'HN', 'HR', 'HT', 'HU', 'ID', 'IE', 'IL', 
-                         'IM', 'IS', 'IN', 'IO', 'IQ', 'IR', 'IT', 'JE', 'JM', 'JO', 'JP', 'KE', 'KG', 'KH', 
-                         'KI', 'KM', 'KN', 'KP', 'KR', 'KW', 'KY', 'KZ', 'LA', 'LB', 'LC', 'LI', 'LK', 'LR', 
-                         'LS', 'LT', 'LU', 'LV', 'LY', 'MA', 'MC', 'MD', 'ME', 'MF', 'MG', 'MH', 'MK', 'ML', 
-                         'MM', 'MN', 'MO', 'MP', 'MQ', 'MR', 'MS', 'MT', 'MU', 'MV', 'MW', 'MX', 'MY', 'MZ', 
-                         'NA', 'NC', 'NE', 'NF', 'NG', 'NI', 'NL', 'NO', 'NP', 'NR', 'NU', 'NZ', 'OM', 'PA', 
-                         'PE', 'PF', 'PG', 'PH', 'PK', 'PL', 'PM', 'PN', 'PR', 'PS', 'PT', 'PW', 'PY', 'QA', 
-                         'RE', 'RO', 'RS', 'RU', 'RW', 'SA', 'SB', 'SC', 'SD', 'SE', 'SG', 'SH', 'SI', 'SK', 
-                         'SL', 'SM', 'SN', 'SO', 'SR', 'SS', 'ST', 'SV', 'SX', 'SY', 'SZ', 'TC', 'TD', 'TG', 
-                         'TH', 'TJ', 'TK', 'TL', 'TM', 'TN', 'TO', 'TR', 'TT', 'TV', 'TW', 'TZ', 'UA', 'UG', 
-                         'US', 'UY', 'UZ', 'VA', 'VC', 'VE', 'VG', 'VI', 'VN', 'VU', 'WF', 'WS', 'XK', 'YE', 
-                         'YT', 'ZA', 'ZM', 'ZW']

src/oneme/processors.py

@@ -73,7 +73,14 @@ class Processors:
         payload = {
             "location": "RU",
             "app-update-type": 0, # 1 = принудительное обновление
-            "reg-country-code": self.static.REG_COUNTRY_CODES,
+            "reg-country-code": [
+                # Список стран, который отдает официальный сервер
+                "AZ", "AM", "KZ", "KG", "MD", "TJ", "UZ", "GE", "TH", "TR", 
+                "TM", "AE", "LA", "MY", "ID", "CU", "KH", "VN", 
+
+                # Список стран, который приделали уже мы                 
+                "US", "CA", "UA"
+            ],
             "phone-auto-complete-enabled": False,
             "lang": True
         }

src/tamtam/processors.py

@@ -1,32 +1,102 @@
 import hashlib
 import secrets
 import time
+import logging
 import json
 import re
-from classes.baseprocessor import BaseProcessor
+from common.static import Static
-from tamtam.models import (
+from common.tools import Tools
-    RequestCodePayloadModel,
+
-    VerifyCodePayloadModel,
+from common.proto_tcp import MobileProto
-    FinalAuthPayloadModel,
+from common.proto_web import WebProto
-    LoginPayloadModel,
+from common.opcodes import Opcodes
-)
+
+from tamtam.models import *
+
+
+class Processors:
+    def __init__(self, db_pool=None, clients=None, send_event=None, type="socket"):
+        if clients is None:
+            clients = {}  # Более правильная логика
+        self.static = Static()
+        self.tools = Tools()
+        self.opcodes = Opcodes()
+        self.error_types = self.static.ErrorTypes()
+        self.db_pool = db_pool
+        self.logger = logging.getLogger(__name__)
+
+        if type == "socket":
+            self.proto = MobileProto()
+        elif type == "web":
+            self.proto = WebProto()
+
+    async def _send(self, writer, packet):
+        try:
+            writer.write(packet)
+            await writer.drain()
+        except:
+            pass
+
+    async def _send_error(self, seq, opcode, type, writer):
+        payload = self.static.ERROR_TYPES.get(type, {
+            "localizedMessage": "Неизвестная ошибка",
+            "error": "unknown.error",
+            "message": "Unknown error",
+            "title": "Неизвестная ошибка"
+        })
+
+        packet = self.proto.pack_packet(
+            cmd=self.proto.CMD_ERR, seq=seq, opcode=opcode, payload=payload
+        )
+
+        await self._send(writer, packet)
+
+    async def session_init(self, payload, seq, writer):
+        """Обработчик приветствия"""
+        # Валидируем данные пакета
+        try:
+            HelloPayloadModel.model_validate(payload)
+        except Exception as e:
+            await self._send_error(seq, self.opcodes.SESSION_INIT, self.error_types.INVALID_PAYLOAD, writer)
+            return None, None
+
+        # Получаем данные из пакета
+        device_type = payload.get("userAgent").get("deviceType")
+        device_name = payload.get("userAgent").get("deviceName")
+
+        # Данные пакета
+        payload = {
+            "proxy": "",
+            "logs-enabled": False,
+            "proxy-domains": [],
+            "location": "RU",
+            "libh-enabled": False,
+            "phone-auto-complete-enabled": False
+        }
+
+        # Собираем пакет
+        packet = self.proto.pack_packet(
+            cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.SESSION_INIT, payload=payload
+        )
+
+        # Отправляем
+        await self._send(writer, packet)
+        return device_type, device_name
 
-class AuthProcessors(BaseProcessor):
     async def auth_request(self, payload, seq, writer):
         """Обработчик запроса кода"""
         # Валидируем данные пакета
         try:
             RequestCodePayloadModel.model_validate(payload)
         except Exception as e:
-            await self._send_error(seq, self.opcodes.AUTH_REQUEST,
+            await self._send_error(seq, self.opcodes.AUTH_REQUEST, self.error_types.INVALID_PAYLOAD, writer)
-                                   self.error_types.INVALID_PAYLOAD, writer)
             return
 
         # Извлекаем телефон из пакета
-        phone = re.sub(r'\D', '', payload.get("phone", ""))
+        phone = re.sub(r'\D', '', payload.get("phone", ""))  # Не хардкодим, через регулярки
 
         # Генерируем токен с кодом
-        code = f"{secrets.randbelow(1_000_000):06d}"
+        code = f"{secrets.randbelow(1_000_000):06d}"  # Старая версия ненадежна, могла отбросить ведущие нули или вообще интерпритировать как систему счисления с основанием 8
         token = secrets.token_urlsafe(128)
 
         # Хешируем
@@ -44,10 +114,8 @@ class AuthProcessors(BaseProcessor):
 
                 # Если пользователь существует, сохраняем токен
                 if user:
-                    await cursor.execute(
+                    # Сохраняем токен
-                        "INSERT INTO auth_tokens (phone, token_hash, code_hash, expires, state) VALUES (%s, %s, %s, %s, %s)",
+                    await cursor.execute("INSERT INTO auth_tokens (phone, token_hash, code_hash, expires, state) VALUES (%s, %s, %s, %s, %s)", (phone, token_hash, code_hash, expires, "started",))
-                        (phone, token_hash, code_hash, expires, "started")
-                    )
 
         # Данные пакета
         payload = {
@@ -74,8 +142,7 @@ class AuthProcessors(BaseProcessor):
         try:
             VerifyCodePayloadModel.model_validate(payload)
         except Exception as e:
-            await self._send_error(seq, self.opcodes.AUTH,
+            await self._send_error(seq, self.opcodes.AUTH, self.error_types.INVALID_PAYLOAD, writer)
-                                   self.error_types.INVALID_PAYLOAD, writer)
             return
 
         # Извлекаем данные из пакета
@@ -90,21 +157,17 @@ class AuthProcessors(BaseProcessor):
         async with self.db_pool.acquire() as conn:
             async with conn.cursor() as cursor:
                 # Ищем токен
-                await cursor.execute(
+                await cursor.execute("SELECT * FROM auth_tokens WHERE token_hash = %s AND expires > UNIX_TIMESTAMP()",
-                    "SELECT * FROM auth_tokens WHERE token_hash = %s AND expires > UNIX_TIMESTAMP()",
+                                     (hashed_token,))
-                    (hashed_token,)
-                )
                 stored_token = await cursor.fetchone()
 
                 if not stored_token:
-                    await self._send_error(seq, self.opcodes.AUTH,
+                    await self._send_error(seq, self.opcodes.AUTH, self.error_types.CODE_EXPIRED, writer)
-                                           self.error_types.CODE_EXPIRED, writer)
                     return
 
                 # Проверяем код
                 if stored_token.get("code_hash") != hashed_code:
-                    await self._send_error(seq, self.opcodes.AUTH,
+                    await self._send_error(seq, self.opcodes.AUTH, self.error_types.INVALID_CODE, writer)
-                                           self.error_types.INVALID_CODE, writer)
                     return
 
                 # Ищем аккаунт
@@ -112,10 +175,7 @@ class AuthProcessors(BaseProcessor):
                 account = await cursor.fetchone()
 
                 # Обновляем состояние токена
-                await cursor.execute(
+                await cursor.execute("UPDATE auth_tokens set state = %s WHERE token_hash = %s", ("verified", hashed_token,))
-                    "UPDATE auth_tokens set state = %s WHERE token_hash = %s",
-                    ("verified", hashed_token)
-                )
 
         # Генерируем профиль
         # Аватарка с биографией
@@ -159,8 +219,7 @@ class AuthProcessors(BaseProcessor):
         try:
             FinalAuthPayloadModel.model_validate(payload)
         except Exception as e:
-            await self._send_error(seq, self.opcodes.AUTH_CONFIRM,
+            await self._send_error(seq, self.opcodes.AUTH_CONFIRM, self.error_types.INVALID_PAYLOAD, writer)
-                                   self.error_types.INVALID_PAYLOAD, writer)
             return
 
         # Извлекаем данные из пакета
@@ -180,21 +239,17 @@ class AuthProcessors(BaseProcessor):
         async with self.db_pool.acquire() as conn:
             async with conn.cursor() as cursor:
                 # Ищем токен
-                await cursor.execute(
+                await cursor.execute("SELECT * FROM auth_tokens WHERE token_hash = %s AND expires > UNIX_TIMESTAMP()",
-                    "SELECT * FROM auth_tokens WHERE token_hash = %s AND expires > UNIX_TIMESTAMP()",
+                                     (hashed_token,))
-                    (hashed_token,)
-                )
                 stored_token = await cursor.fetchone()
 
                 if stored_token is None:
-                    await self._send_error(seq, self.opcodes.AUTH_CONFIRM,
+                    await self._send_error(seq, self.opcodes.AUTH_CONFIRM, self.error_types.INVALID_TOKEN, writer)
-                                           self.error_types.INVALID_TOKEN, writer)
                     return
 
                 # Если авторизация только началась - отдаем ошибку
                 if stored_token.get("state") == "started":
-                    await self._send_error(seq, self.opcodes.AUTH_CONFIRM,
+                    await self._send_error(seq, self.opcodes.AUTH_CONFIRM, self.error_types.INVALID_TOKEN, writer)
-                                           self.error_types.INVALID_TOKEN, writer)
                     return
 
                 # Ищем аккаунт
@@ -207,18 +262,18 @@ class AuthProcessors(BaseProcessor):
                 # Создаем сессию
                 await cursor.execute(
                     "INSERT INTO tokens (phone, token_hash, device_type, device_name, location, time) VALUES (%s, %s, %s, %s, %s, %s)",
-                    (stored_token.get("phone"), hashed_login, deviceType, deviceName,
+                    (stored_token.get("phone"), hashed_login, deviceType, deviceName, "Epstein Island",
-                     "Epstein Island", int(time.time()))
+                     int(time.time()),)
                 )
 
         # Аватарка с биографией
         photo_id = None if not account.get("avatar_id") else int(account.get("avatar_id"))
-        avatar_url = None if not photo_id else self.config.avatar_base_url + str(photo_id)
+        avatar_url = None if not photo_id else self.config.avatar_base_url + photo_id
         description = None if not account.get("description") else account.get("description")
 
         # Собираем данные пакета
         payload = {
-            "userToken": "0",  # Пока как заглушка
+            "userToken": "0", # Пока как заглушка
             "profile": self.tools.generate_profile_tt(
                 id=account.get("id"),
                 phone=int(account.get("phone")),
@@ -240,7 +295,7 @@ class AuthProcessors(BaseProcessor):
             cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.AUTH_CONFIRM, payload=payload
         )
 
-        # Отправляем
+        # Отправялем
         await self._send(writer, packet)
 
     async def login(self, payload, seq, writer):
@@ -248,12 +303,11 @@ class AuthProcessors(BaseProcessor):
         # Валидируем данные пакета
         try:
             LoginPayloadModel.model_validate(payload)
-        except Exception as e:
+        except pydantic.ValidationError as error:
-            self.logger.error(f"Возникли ошибки при валидации пакета: {e}")
+            self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
-            await self._send_error(seq, self.opcodes.LOGIN,
+            await self._send_error(seq, self.opcodes.LOGIN, self.error_types.INVALID_PAYLOAD, writer)
-                                   self.error_types.INVALID_PAYLOAD, writer)
             return
-
+        
         # Получаем данные из пакета
         token = payload.get("token")
 
@@ -268,8 +322,7 @@ class AuthProcessors(BaseProcessor):
 
                 # Если токен не найден, отправляем ошибку
                 if token_data is None:
-                    await self._send_error(seq, self.opcodes.LOGIN,
+                    await self._send_error(seq, self.opcodes.LOGIN, self.error_types.INVALID_TOKEN, writer)
-                                           self.error_types.INVALID_TOKEN, writer)
                     return
 
                 # Ищем аккаунт пользователя в бд
@@ -282,7 +335,7 @@ class AuthProcessors(BaseProcessor):
 
         # Аватарка с биографией
         photo_id = None if not user.get("avatar_id") else int(user.get("avatar_id"))
-        avatar_url = None if not photo_id else self.config.avatar_base_url + str(photo_id)
+        avatar_url = None if not photo_id else self.config.avatar_base_url + photo_id
         description = None if not user.get("description") else user.get("description")
 
         # Генерируем профиль
@@ -325,14 +378,14 @@ class AuthProcessors(BaseProcessor):
             "calls": [],
             "videoChatHistory": False,
             "drafts": {
-                "chats": {
+            "chats": {
-                    "discarded": {},
+                "discarded": {},
-                    "saved": {}
+                "saved": {}
-                },
+            },
-                "users": {
+            "users": {
-                    "discarded": {},
+                "discarded": {},
-                    "saved": {}
+                "saved": {}
-                }
+            }
             },
             "time": int(time.time() * 1000)
         }

src/tamtam/processors/__init__.py

@@ -1,5 +0,0 @@
-from .main import MainProcessors
-from .auth import AuthProcessors
-
-class Processors(MainProcessors, AuthProcessors):
-    pass

src/tamtam/processors/main.py

@@ -1,36 +0,0 @@
-from classes.baseprocessor import BaseProcessor
-from tamtam.models import HelloPayloadModel
-
-class MainProcessors(BaseProcessor):
-    async def session_init(self, payload, seq, writer):
-        """Обработчик приветствия"""
-        # Валидируем данные пакета
-        try:
-            HelloPayloadModel.model_validate(payload)
-        except Exception as e:
-            await self._send_error(seq, self.opcodes.SESSION_INIT,
-                                   self.error_types.INVALID_PAYLOAD, writer)
-            return None, None
-
-        # Получаем данные из пакета
-        device_type = payload.get("userAgent").get("deviceType")
-        device_name = payload.get("userAgent").get("deviceName")
-
-        # Данные пакета
-        payload = {
-            "proxy": "",
-            "logs-enabled": False,
-            "proxy-domains": [],
-            "location": "RU",
-            "libh-enabled": False,
-            "phone-auto-complete-enabled": False
-        }
-
-        # Собираем пакет
-        packet = self.proto.pack_packet(
-            cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.SESSION_INIT, payload=payload
-        )
-
-        # Отправляем
-        await self._send(writer, packet)
-        return device_type, device_name