py-mtproxy-lib 0.0.1__py3-none-any.whl

mtproxy/__init__.py

@@ -0,0 +1,23 @@
+"""
+py-mtproxy-lib - Python библиотека для запуска MTProto прокси
+"""
+
+from .server import MTProxyServer
+from .utils import generate_secret
+from .stats import ProxyStats, ConnectionStats
+from .logger import setup_logger
+from .config import ProxyConfig
+from .daemon import Daemon
+from .cli import main
+
+__version__ = "2.0.0"
+__all__ = [
+    'MTProxyServer',
+    'generate_secret',
+    'ProxyStats',
+    'ConnectionStats',
+    'setup_logger',
+    'ProxyConfig',
+    'Daemon',
+    'main'
+]

mtproxy/cli.py

@@ -0,0 +1,192 @@
+"""CLI интерфейс"""
+
+import argparse
+import sys
+import os
+from .config import ProxyConfig
+from .server import MTProxyServer
+from .utils import generate_secret
+from .daemon import Daemon
+from .logger import setup_logger
+
+
+def start_server(config: ProxyConfig, foreground: bool = False):
+    """Запуск сервера"""
+    # Настройка логгера
+    logger = setup_logger(
+        level=config.log_level,
+        log_file=config.log_file
+    )
+    
+    server = MTProxyServer(config)
+    
+    if foreground:
+        server.start()
+    else:
+        daemon = Daemon(
+            pidfile=config.pid_file or '/var/run/mtproxy.pid',
+            stdout=config.log_file or '/dev/null',
+            stderr=config.log_file or '/dev/null'
+        )
+        daemon.start(server.start)
+
+
+def main():
+    """Основная функция CLI"""
+    parser = argparse.ArgumentParser(
+        description="MTProto Proxy Server",
+        prog="mtproxy"
+    )
+    
+    parser.add_argument(
+        "-c", "--config",
+        help="Config file path",
+        type=str,
+        default="mtproxy.conf"
+    )
+    
+    parser.add_argument(
+        "-s", "--secret",
+        help="Add secret (can be used multiple times)",
+        action="append"
+    )
+    
+    parser.add_argument(
+        "-p", "--port",
+        help="Port to listen on",
+        type=int
+    )
+    
+    parser.add_argument(
+        "--no-fake-tls",
+        help="Disable Fake TLS masking",
+        action="store_true"
+    )
+    
+    parser.add_argument(
+        "-d", "--daemon",
+        help="Run as daemon",
+        action="store_true"
+    )
+    
+    parser.add_argument(
+        "--pid-file",
+        help="PID file path",
+        type=str
+    )
+    
+    parser.add_argument(
+        "--log-file",
+        help="Log file path",
+        type=str
+    )
+    
+    parser.add_argument(
+        "--log-level",
+        help="Log level",
+        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+        default='INFO'
+    )
+    
+    parser.add_argument(
+        "--stats-interval",
+        help="Statistics output interval (seconds)",
+        type=int
+    )
+    
+    parser.add_argument(
+        "--generate-secret",
+        help="Generate random secret and exit",
+        action="store_true"
+    )
+    
+    parser.add_argument(
+        "--show-links",
+        help="Show connection links",
+        action="store_true"
+    )
+    
+    # Команды управления демоном
+    subparsers = parser.add_subparsers(dest="command", help="Daemon commands")
+    
+    subparsers.add_parser("start", help="Start daemon")
+    subparsers.add_parser("stop", help="Stop daemon")
+    subparsers.add_parser("restart", help="Restart daemon")
+    subparsers.add_parser("status", help="Check daemon status")
+    
+    args = parser.parse_args()
+    
+    # Генерация секрета
+    if args.generate_secret:
+        print(generate_secret())
+        sys.exit(0)
+    
+    # Загрузка конфигурации
+    config = None
+    if os.path.exists(args.config):
+        try:
+            config = ProxyConfig.from_file(args.config)
+        except Exception as e:
+            print(f"Error loading config: {e}", file=sys.stderr)
+    
+    if not config:
+        config = ProxyConfig()
+    
+    # Применение CLI аргументов
+    if args.port:
+        config.port = args.port
+    if args.no_fake_tls:
+        config.enable_fake_tls = False
+    if args.pid_file:
+        config.pid_file = args.pid_file
+    if args.log_file:
+        config.log_file = args.log_file
+    if args.log_level:
+        config.log_level = args.log_level
+    if args.stats_interval:
+        config.stats_interval = args.stats_interval
+    
+    # Добавление секретов
+    if args.secret:
+        for secret in args.secret:
+            config.add_secret(secret)
+    
+    # Если нет секретов, создаем один
+    if not config.secrets:
+        config.add_secret()
+        print(f"Generated default secret: {list(config.secrets.keys())[0]}")
+    
+    # Показ ссылок
+    if args.show_links:
+        links = config.get_connection_links()
+        print("Connection links:")
+        for name, link in links.items():
+            print(f"  {name}: {link}")
+        sys.exit(0)
+    
+    # Команды демона
+    daemon = Daemon(
+        pidfile=config.pid_file or '/var/run/mtproxy.pid',
+        stdout=config.log_file or '/dev/null',
+        stderr=config.log_file or '/dev/null'
+    )
+    
+    if args.command == "start":
+        sys.exit(daemon.start(start_server, config))
+    elif args.command == "stop":
+        sys.exit(daemon.stop())
+    elif args.command == "restart":
+        sys.exit(daemon.restart(start_server, config))
+    elif args.command == "status":
+        print(daemon.status())
+        sys.exit(0)
+    
+    # Запуск в foreground или daemon
+    if args.daemon:
+        daemon.start(start_server, config)
+    else:
+        start_server(config, foreground=True)
+
+
+if __name__ == "__main__":
+    main()

mtproxy/config.py

@@ -0,0 +1,161 @@
+"""Конфигурация с поддержкой нескольких секретов"""
+
+import json
+import os
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+from .utils import generate_secret, verify_fake_tls_handshake
+
+
+@dataclass
+class ProxyConfig:
+    """
+    Конфигурация прокси сервера с поддержкой нескольких секретов
+    
+    Attributes:
+        secrets (Dict[str, str]): Словарь {secret: tag}
+        port (int): Порт для прослушивания
+        enable_fake_tls (bool): Включить Fake TLS маскировку
+        handshake_timeout (int): Таймаут handshake в секундах
+        stats_interval (int): Интервал вывода статистики (сек)
+        log_level (str): Уровень логирования
+        log_file (Optional[str]): Файл лога
+        pid_file (Optional[str]): Файл PID
+    """
+    
+    secrets: Dict[str, str] = field(default_factory=dict)
+    port: int = 443
+    enable_fake_tls: bool = True
+    handshake_timeout: int = 10
+    stats_interval: int = 60
+    log_level: str = "INFO"
+    log_file: Optional[str] = None
+    pid_file: Optional[str] = None
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ProxyConfig':
+        """Создание конфигурации из словаря"""
+        secrets = {}
+        
+        # Поддержка разных форматов
+        if 'secrets' in data:
+            if isinstance(data['secrets'], list):
+                for item in data['secrets']:
+                    if isinstance(item, str):
+                        secrets[item] = ""
+                    elif isinstance(item, dict):
+                        secrets[item.get('secret', '')] = item.get('tag', '')
+            elif isinstance(data['secrets'], dict):
+                secrets = data['secrets']
+        
+        return cls(
+            secrets=secrets,
+            port=data.get('port', 443),
+            enable_fake_tls=data.get('enable_fake_tls', True),
+            handshake_timeout=data.get('handshake_timeout', 10),
+            stats_interval=data.get('stats_interval', 60),
+            log_level=data.get('log_level', 'INFO'),
+            log_file=data.get('log_file'),
+            pid_file=data.get('pid_file')
+        )
+    
+    @classmethod
+    def from_file(cls, path: str) -> 'ProxyConfig':
+        """Загрузка конфигурации из файла"""
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Config file not found: {path}")
+        
+        with open(path, 'r') as f:
+            if path.endswith('.json'):
+                data = json.load(f)
+            else:
+                # INI-like format
+                data = cls._parse_ini(f.read())
+        
+        return cls.from_dict(data)
+    
+    @classmethod
+    def _parse_ini(cls, content: str) -> dict:
+        """Парсинг INI-подобного формата"""
+        data = {'secrets': {}}
+        
+        for line in content.split('\n'):
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            
+            if '=' in line:
+                key, value = line.split('=', 1)
+                key = key.strip()
+                value = value.strip()
+                
+                if key == 'secret':
+                    # Простой формат: secret=xxx
+                    data['secrets'][value] = ""
+                elif key.startswith('secret_'):
+                    # Формат: secret_name=xxx
+                    tag = key.replace('secret_', '')
+                    data['secrets'][value] = tag
+                else:
+                    # Другие параметры
+                    data[key] = value
+        
+        return data
+    
+    def save(self, path: str) -> None:
+        """Сохранение конфигурации в файл"""
+        data = {
+            'port': self.port,
+            'enable_fake_tls': self.enable_fake_tls,
+            'handshake_timeout': self.handshake_timeout,
+            'stats_interval': self.stats_interval,
+            'log_level': self.log_level,
+            'secrets': self.secrets
+        }
+        
+        with open(path, 'w') as f:
+            json.dump(data, f, indent=2)
+    
+    def add_secret(self, secret: Optional[str] = None, tag: str = "") -> str:
+        """Добавление нового секрета"""
+        if not secret:
+            secret = generate_secret()
+        
+        self.secrets[secret] = tag
+        return secret
+    
+    def remove_secret(self, secret: str) -> bool:
+        """Удаление секрета"""
+        if secret in self.secrets:
+            del self.secrets[secret]
+            return True
+        return False
+    
+    def verify_secret(self, data: bytes) -> Tuple[bool, Optional[str]]:
+        """
+        Проверка handshake и определение использованного секрета
+        
+        Returns:
+            Tuple[bool, Optional[str]]: (успех, секрет)
+        """
+        for secret_hex, tag in self.secrets.items():
+            secret = bytes.fromhex(secret_hex)
+            if verify_fake_tls_handshake(data, secret):
+                return True, secret_hex
+        
+        return False, None
+    
+    def get_connection_links(self, base_ip: Optional[str] = None) -> Dict[str, str]:
+        """Получение ссылок для всех секретов"""
+        from .utils import get_external_ip
+        
+        ip = base_ip or get_external_ip() or "YOUR_SERVER_IP"
+        links = {}
+        
+        for secret, tag in self.secrets.items():
+            link = f"tg://proxy?server={ip}&port={self.port}&secret={secret}"
+            if tag:
+                link += f"&tag={tag}"
+            links[secret[:16] + ("..." if len(secret) > 16 else "")] = link
+        
+        return links

mtproxy/daemon.py

@@ -0,0 +1,192 @@
+"""Модуль для запуска как системный демон"""
+
+import os
+import sys
+import atexit
+import signal
+import time
+from typing import Optional, Callable
+
+
+class Daemon:
+    """
+    Класс для управления демоном
+    
+    Пример использования:
+        daemon = Daemon(pidfile='/var/run/mtproxy.pid')
+        daemon.start(run_function)
+    """
+    
+    def __init__(self, pidfile: str, stdin: str = '/dev/null',
+                 stdout: str = '/dev/null', stderr: str = '/dev/null'):
+        """
+        Инициализация демона
+        
+        Args:
+            pidfile: Путь к файлу PID
+            stdin: Перенаправление stdin
+            stdout: Перенаправление stdout
+            stderr: Перенаправление stderr
+        """
+        self.pidfile = pidfile
+        self.stdin = stdin
+        self.stdout = stdout
+        self.stderr = stderr
+        self._running = False
+    
+    def _daemonize(self) -> None:
+        """Демонизация процесса (двойной fork)"""
+        try:
+            pid = os.fork()
+            if pid > 0:
+                sys.exit(0)
+        except OSError as e:
+            sys.stderr.write(f"Fork #1 failed: {e}\n")
+            sys.exit(1)
+        
+        # Отсоединение от терминала
+        os.setsid()
+        os.umask(0)
+        
+        try:
+            pid = os.fork()
+            if pid > 0:
+                sys.exit(0)
+        except OSError as e:
+            sys.stderr.write(f"Fork #2 failed: {e}\n")
+            sys.exit(1)
+        
+        # Перенаправление файловых дескрипторов
+        sys.stdout.flush()
+        sys.stderr.flush()
+        
+        with open(self.stdin, 'r') as si:
+            os.dup2(si.fileno(), sys.stdin.fileno())
+        with open(self.stdout, 'a+') as so:
+            os.dup2(so.fileno(), sys.stdout.fileno())
+        with open(self.stderr, 'a+') as se:
+            os.dup2(se.fileno(), sys.stderr.fileno())
+        
+        # Запись PID
+        self._write_pidfile()
+        
+        # Регистрация удаления PID файла при выходе
+        atexit.register(self._remove_pidfile)
+        
+        # Обработка сигналов
+        signal.signal(signal.SIGTERM, self._signal_handler)
+        signal.signal(signal.SIGINT, self._signal_handler)
+    
+    def _write_pidfile(self) -> None:
+        """Запись PID в файл"""
+        with open(self.pidfile, 'w') as f:
+            f.write(str(os.getpid()))
+    
+    def _remove_pidfile(self) -> None:
+        """Удаление PID файла"""
+        if os.path.exists(self.pidfile):
+            os.remove(self.pidfile)
+    
+    def _signal_handler(self, signum, frame) -> None:
+        """Обработчик сигналов"""
+        self._running = False
+    
+    def _get_pid(self) -> Optional[int]:
+        """Получение PID из файла"""
+        try:
+            with open(self.pidfile, 'r') as f:
+                return int(f.read().strip())
+        except (IOError, ValueError):
+            return None
+    
+    def start(self, run_func: Callable, *args, **kwargs) -> int:
+        """
+        Запуск демона
+        
+        Args:
+            run_func: Функция для запуска
+            *args, **kwargs: Аргументы для функции
+        
+        Returns:
+            int: 0 при успехе, 1 при ошибке
+        """
+        pid = self._get_pid()
+        
+        if pid:
+            # Проверка, работает ли процесс
+            try:
+                os.kill(pid, 0)
+                sys.stderr.write(f"Daemon already running with PID {pid}\n")
+                return 1
+            except OSError:
+                # Процесс не работает, удаляем старый PID файл
+                self._remove_pidfile()
+        
+        # Демонизация
+        self._daemonize()
+        
+        # Запуск основной функции
+        self._running = True
+        try:
+            run_func(*args, **kwargs)
+        except KeyboardInterrupt:
+            pass
+        except Exception as e:
+            sys.stderr.write(f"Error in daemon: {e}\n")
+            return 1
+        
+        return 0
+    
+    def stop(self) -> int:
+        """Остановка демона"""
+        pid = self._get_pid()
+        
+        if not pid:
+            sys.stderr.write("Daemon not running\n")
+            return 1
+        
+        try:
+            os.kill(pid, signal.SIGTERM)
+            
+            # Ожидание завершения
+            timeout = 10
+            while timeout > 0:
+                try:
+                    os.kill(pid, 0)
+                    time.sleep(0.5)
+                    timeout -= 0.5
+                except OSError:
+                    break
+            
+            # Принудительное завершение
+            try:
+                os.kill(pid, 0)
+                os.kill(pid, signal.SIGKILL)
+            except OSError:
+                pass
+            
+            self._remove_pidfile()
+            
+        except OSError as e:
+            sys.stderr.write(f"Error stopping daemon: {e}\n")
+            return 1
+        
+        return 0
+    
+    def restart(self, run_func: Callable, *args, **kwargs) -> int:
+        """Перезапуск демона"""
+        self.stop()
+        return self.start(run_func, *args, **kwargs)
+    
+    def status(self) -> str:
+        """Проверка статуса демона"""
+        pid = self._get_pid()
+        
+        if not pid:
+            return "stopped"
+        
+        try:
+            os.kill(pid, 0)
+            return f"running (PID: {pid})"
+        except OSError:
+            return "stopped (stale PID file)"

mtproxy/logger.py

@@ -0,0 +1,102 @@
+"""Модуль логирования"""
+
+import logging
+import sys
+from typing import Optional
+from logging.handlers import RotatingFileHandler
+
+
+class ColoredFormatter(logging.Formatter):
+    """Форматирование с цветами для консоли"""
+    
+    COLORS = {
+        'DEBUG': '\033[36m',     # Cyan
+        'INFO': '\033[32m',      # Green
+        'WARNING': '\033[33m',   # Yellow
+        'ERROR': '\033[31m',     # Red
+        'CRITICAL': '\033[35m',  # Magenta
+    }
+    RESET = '\033[0m'
+    
+    def format(self, record):
+        levelname = record.levelname
+        if levelname in self.COLORS:
+            record.levelname = f"{self.COLORS[levelname]}{levelname}{self.RESET}"
+        return super().format(record)
+
+
+def setup_logger(
+    name: str = "mtproxy",
+    level: str = "INFO",
+    log_file: Optional[str] = None,
+    console: bool = True,
+    max_bytes: int = 10 * 1024 * 1024,  # 10 MB
+    backup_count: int = 5
+) -> logging.Logger:
+    """
+    Настройка логгера
+    
+    Args:
+        name: Имя логгера
+        level: Уровень логирования (DEBUG, INFO, WARNING, ERROR)
+        log_file: Путь к файлу лога (опционально)
+        console: Вывод в консоль
+        max_bytes: Максимальный размер файла лога
+        backup_count: Количество резервных копий
+    
+    Returns:
+        logging.Logger: Настроенный логгер
+    """
+    logger = logging.getLogger(name)
+    
+    # Очистка существующих обработчиков
+    logger.handlers.clear()
+    
+    # Установка уровня
+    level_map = {
+        'DEBUG': logging.DEBUG,
+        'INFO': logging.INFO,
+        'WARNING': logging.WARNING,
+        'ERROR': logging.ERROR,
+        'CRITICAL': logging.CRITICAL
+    }
+    logger.setLevel(level_map.get(level.upper(), logging.INFO))
+    
+    # Формат логов
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    # Консольный вывод
+    if console:
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setFormatter(ColoredFormatter(
+            '%(asctime)s - %(levelname)s - %(message)s',
+            datefmt='%H:%M:%S'
+        ))
+        logger.addHandler(console_handler)
+    
+    # Файловый вывод
+    if log_file:
+        file_handler = RotatingFileHandler(
+            log_file,
+            maxBytes=max_bytes,
+            backupCount=backup_count
+        )
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+
+# Глобальный логгер
+_default_logger = None
+
+
+def get_logger() -> logging.Logger:
+    """Получение глобального логгера"""
+    global _default_logger
+    if _default_logger is None:
+        _default_logger = setup_logger()
+    return _default_logger

mtproxy/server.py

@@ -0,0 +1,235 @@
+"""Основной класс MTProto прокси сервера"""
+
+import asyncio
+import uuid
+import signal
+import time
+from typing import Optional, Dict, Callable
+from .config import ProxyConfig
+from .stats import ProxyStats
+from .logger import get_logger
+from .utils import verify_fake_tls_handshake, get_external_ip
+
+
+class MTProxyServer:
+    """
+    MTProto прокси сервер с поддержкой нескольких секретов и статистики
+    """
+    
+    def __init__(self, config: ProxyConfig):
+        """
+        Инициализация прокси сервера
+        
+        Args:
+            config: Конфигурация прокси
+        """
+        self.config = config
+        self.logger = get_logger()
+        self.stats = ProxyStats()
+        self.server: Optional[asyncio.Server] = None
+        self._running = False
+        self._tasks: Dict[str, asyncio.Task] = {}
+        self._conn_counter = 0
+    
+    def _get_conn_id(self) -> str:
+        """Генерация ID для соединения"""
+        self._conn_counter += 1
+        return f"{self._conn_counter}_{uuid.uuid4().hex[:8]}"
+    
+    async def _handle_connection(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter
+    ):
+        """Обработка входящего подключения"""
+        conn_id = self._get_conn_id()
+        client_addr = writer.get_extra_info('peername')
+        client_ip = client_addr[0] if client_addr else "unknown"
+        
+        try:
+            # Чтение handshake
+            handshake = await asyncio.wait_for(
+                reader.read(1024),
+                timeout=self.config.handshake_timeout
+            )
+            
+            if not handshake:
+                writer.close()
+                return
+            
+            # Аутентификация с несколькими секретами
+            if self.config.enable_fake_tls and handshake[0] == 0x16:
+                success, secret = self.config.verify_secret(handshake)
+                if not success:
+                    self.logger.warning(f"Auth failed from {client_ip}")
+                    writer.close()
+                    return
+            else:
+                # Классический режим - проверяем первый секрет
+                if len(handshake) < 4 or handshake[:4] != b'\xef\xef\xef\xef':
+                    self.logger.warning(f"Invalid protocol from {client_ip}")
+                    writer.close()
+                    return
+                secret = list(self.config.secrets.keys())[0] if self.config.secrets else None
+                if not secret:
+                    writer.close()
+                    return
+            
+            self.logger.info(f"Client connected: {client_ip} (secret: {secret[:16]}...)")
+            
+            # Регистрация соединения в статистике
+            self.stats.connection_started(conn_id, client_ip, secret)
+            
+            # Подключение к Telegram
+            # Используем несколько IP для балансировки
+            tg_ips = ['149.154.167.50', '149.154.167.51', '149.154.175.100']
+            tg_reader, tg_writer = await asyncio.open_connection(
+                tg_ips[hash(secret) % len(tg_ips)],
+                443
+            )
+            
+            # Создание задач для пересылки данных
+            task_client = asyncio.create_task(
+                self._forward(reader, tg_writer, conn_id, sent=True)
+            )
+            task_server = asyncio.create_task(
+                self._forward(tg_reader, writer, conn_id, received=True)
+            )
+            
+            self._tasks[conn_id] = task_client
+            self._tasks[f"{conn_id}_server"] = task_server
+            
+            # Ожидание завершения
+            await asyncio.gather(task_client, task_server)
+            
+        except asyncio.TimeoutError:
+            self.logger.debug(f"Handshake timeout from {client_ip}")
+        except ConnectionRefusedError:
+            self.logger.error(f"Connection refused to Telegram from {client_ip}")
+        except Exception as e:
+            self.logger.error(f"Error handling connection from {client_ip}: {e}")
+        finally:
+            # Завершение соединения
+            self.stats.connection_ended(conn_id)
+            
+            # Удаление задач
+            for task_id in [conn_id, f"{conn_id}_server"]:
+                if task_id in self._tasks:
+                    self._tasks[task_id].cancel()
+                    del self._tasks[task_id]
+            
+            writer.close()
+            await writer.wait_closed()
+            
+            self.logger.debug(f"Connection closed: {client_ip}")
+    
+    async def _forward(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+        conn_id: str,
+        sent: bool = False,
+        received: bool = False
+    ):
+        """Пересылка данных с обновлением статистики"""
+        try:
+            while True:
+                data = await reader.read(8192)
+                if not data:
+                    break
+                
+                writer.write(data)
+                await writer.drain()
+                
+                # Обновление статистики
+                if sent:
+                    self.stats.update_bytes(conn_id, sent=len(data))
+                if received:
+                    self.stats.update_bytes(conn_id, received=len(data))
+                    
+        except (asyncio.CancelledError, ConnectionError):
+            pass
+        except Exception as e:
+            self.logger.debug(f"Forward error: {e}")
+        finally:
+            writer.close()
+    
+    async def _stats_reporter(self):
+        """Периодический вывод статистики"""
+        while self._running:
+            await asyncio.sleep(self.config.stats_interval)
+            self.logger.info("\n" + self.stats.format_summary())
+    
+    def start(self):
+        """Запуск прокси сервера"""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        self._running = True
+        
+        try:
+            # Запуск сервера
+            self.server = loop.run_until_complete(
+                asyncio.start_server(
+                    self._handle_connection,
+                    '0.0.0.0',
+                    self.config.port
+                )
+            )
+            
+            # Запуск репортера статистики
+            stats_task = loop.create_task(self._stats_reporter())
+            
+            # Вывод информации
+            print("=" * 60)
+            print("🚀 MTProxy Server Started")
+            print("=" * 60)
+            print(f"📡 Port: {self.config.port}")
+            print(f"🔐 Fake TLS: {self.config.enable_fake_tls}")
+            print(f"🔑 Secrets count: {len(self.config.secrets)}")
+            print(f"📊 Stats interval: {self.config.stats_interval}s")
+            print("-" * 60)
+            print("Connection links:")
+            
+            ip = get_external_ip()
+            for secret, tag in self.config.secrets.items():
+                link = f"tg://proxy?server={ip}&port={self.config.port}&secret={secret}"
+                if tag:
+                    link += f"&tag={tag}"
+                print(f"  {link}")
+            
+            print("=" * 60)
+            print("Press Ctrl+C to stop")
+            print("=" * 60)
+            
+            # Обработка сигналов
+            for sig in (signal.SIGINT, signal.SIGTERM):
+                loop.add_signal_handler(sig, lambda: asyncio.create_task(self.stop()))
+            
+            loop.run_forever()
+            
+        except KeyboardInterrupt:
+            pass
+        except Exception as e:
+            self.logger.error(f"Server error: {e}")
+        finally:
+            stats_task.cancel()
+            self._running = False
+            if self.server:
+                self.server.close()
+            loop.close()
+    
+    async def stop(self):
+        """Остановка сервера"""
+        self.logger.info("Shutting down...")
+        self._running = False
+        
+        # Отмена всех задач
+        for task in self._tasks.values():
+            task.cancel()
+        
+        if self.server:
+            self.server.close()
+            await self.server.wait_closed()
+        
+        self.logger.info("Server stopped")

mtproxy/stats.py

@@ -0,0 +1,167 @@
+"""Модуль статистики"""
+
+import time
+import threading
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+from collections import defaultdict
+from datetime import datetime
+
+
+@dataclass
+class ConnectionStats:
+    """Статистика по одному соединению"""
+    client_ip: str
+    secret_key: str
+    start_time: float
+    bytes_sent: int = 0
+    bytes_received: int = 0
+    end_time: Optional[float] = None
+    
+    @property
+    def duration(self) -> float:
+        """Длительность соединения в секундах"""
+        end = self.end_time or time.time()
+        return end - self.start_time
+    
+    @property
+    def total_bytes(self) -> int:
+        """Общее количество байт"""
+        return self.bytes_sent + self.bytes_received
+
+
+class ProxyStats:
+    """
+    Сбор статистики прокси сервера
+    
+    Attributes:
+        total_connections (int): Всего подключений
+        active_connections (int): Активных подключений
+        total_bytes_sent (int): Всего отправлено байт
+        total_bytes_received (int): Всего получено байт
+        connections_per_secret (dict): Статистика по секретам
+        connections_per_ip (dict): Статистика по IP
+    """
+    
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._connections: Dict[str, ConnectionStats] = {}
+        self._start_time = time.time()
+        
+        # Общая статистика
+        self.total_connections = 0
+        self.active_connections = 0
+        self.total_bytes_sent = 0
+        self.total_bytes_received = 0
+        
+        # Детальная статистика
+        self.connections_per_secret: Dict[str, int] = defaultdict(int)
+        self.connections_per_ip: Dict[str, int] = defaultdict(int)
+        self.bytes_per_secret: Dict[str, Dict[str, int]] = defaultdict(
+            lambda: {'sent': 0, 'received': 0}
+        )
+    
+    def connection_started(self, conn_id: str, client_ip: str, secret_key: str) -> None:
+        """Начало соединения"""
+        with self._lock:
+            self._connections[conn_id] = ConnectionStats(
+                client_ip=client_ip,
+                secret_key=secret_key,
+                start_time=time.time()
+            )
+            self.total_connections += 1
+            self.active_connections += 1
+            self.connections_per_secret[secret_key] += 1
+            self.connections_per_ip[client_ip] += 1
+    
+    def connection_ended(self, conn_id: str) -> Optional[ConnectionStats]:
+        """Завершение соединения"""
+        with self._lock:
+            if conn_id not in self._connections:
+                return None
+            
+            conn = self._connections[conn_id]
+            conn.end_time = time.time()
+            
+            self.active_connections -= 1
+            self.total_bytes_sent += conn.bytes_sent
+            self.total_bytes_received += conn.bytes_received
+            
+            # Обновление статистики по секрету
+            self.bytes_per_secret[conn.secret_key]['sent'] += conn.bytes_sent
+            self.bytes_per_secret[conn.secret_key]['received'] += conn.bytes_received
+            
+            return self._connections.pop(conn_id, None)
+    
+    def update_bytes(self, conn_id: str, sent: int = 0, received: int = 0) -> None:
+        """Обновление счетчиков байт"""
+        with self._lock:
+            if conn_id in self._connections:
+                self._connections[conn_id].bytes_sent += sent
+                self._connections[conn_id].bytes_received += received
+    
+    def get_summary(self) -> dict:
+        """Получение сводной статистики"""
+        with self._lock:
+            uptime = time.time() - self._start_time
+            
+            return {
+                'uptime_seconds': uptime,
+                'total_connections': self.total_connections,
+                'active_connections': self.active_connections,
+                'total_bytes_sent': self.total_bytes_sent,
+                'total_bytes_received': self.total_bytes_received,
+                'total_bytes': self.total_bytes_sent + self.total_bytes_received,
+                'connections_per_second': self.total_connections / uptime if uptime > 0 else 0,
+                'bytes_per_second': (self.total_bytes_sent + self.total_bytes_received) / uptime if uptime > 0 else 0,
+                'secrets': dict(self.connections_per_secret),
+                'bytes_per_secret': dict(self.bytes_per_secret),
+                'top_ips': sorted(
+                    self.connections_per_ip.items(),
+                    key=lambda x: x[1],
+                    reverse=True
+                )[:10]
+            }
+    
+    def format_summary(self) -> str:
+        """Форматирование сводки для вывода"""
+        stats = self.get_summary()
+        
+        def format_bytes(b: int) -> str:
+            for unit in ['B', 'KB', 'MB', 'GB']:
+                if b < 1024:
+                    return f"{b:.2f} {unit}"
+                b /= 1024
+            return f"{b:.2f} TB"
+        
+        lines = [
+            "=" * 50,
+            "MTProxy Statistics",
+            "=" * 50,
+            f"Uptime: {stats['uptime_seconds']:.0f} seconds",
+            f"Total connections: {stats['total_connections']}",
+            f"Active connections: {stats['active_connections']}",
+            f"Total traffic: {format_bytes(stats['total_bytes'])}",
+            f"  - Sent: {format_bytes(stats['total_bytes_sent'])}",
+            f"  - Received: {format_bytes(stats['total_bytes_received'])}",
+            f"Connections/sec: {stats['connections_per_second']:.2f}",
+            f"Traffic/sec: {format_bytes(stats['bytes_per_second'])}",
+            "-" * 50,
+            "Statistics by secret:",
+        ]
+        
+        for secret, count in stats['secrets'].items():
+            bytes_stats = stats['bytes_per_secret'].get(secret, {'sent': 0, 'received': 0})
+            total = bytes_stats['sent'] + bytes_stats['received']
+            lines.append(
+                f"  {secret[:16]}...: {count} connections, {format_bytes(total)}"
+            )
+        
+        if stats['top_ips']:
+            lines.append("-" * 50)
+            lines.append("Top 10 IPs:")
+            for ip, count in stats['top_ips']:
+                lines.append(f"  {ip}: {count} connections")
+        
+        lines.append("=" * 50)
+        return "\n".join(lines)

py_mtproxy_lib-0.0.1.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: py-mtproxy-lib
+Version: 0.0.1
+Summary: Production-ready MTProto proxy server library with multi-secret support, statistics, and daemon mode
+Home-page: https://github.com/twosleepynights0x1/py-mtproxy-lib
+Author: Your Name
+Author-email: tashova28@gmail.com
+Project-URL: Bug Reports, https://github.com/twosleepynights0x1/py-mtproxy-lib
+Keywords: mtproto telegram proxy vpn daemon docker
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: pycryptodome>=3.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: flake8>=4.0; extra == "dev"
+Provides-Extra: docker
+Requires-Dist: docker>=6.0; extra == "docker"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# py-mtproxy-lib
+
+Python библиотека для запуска MTProto прокси сервера.
+
+## Установка
+
+```bash
+pip install py-mtproxy-lib

py_mtproxy_lib-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+mtproxy/__init__.py,sha256=9-Zi4TGcbvUxqKgNEaEqbGuZkSRgKV5-W0hsbP8Xaf4,534
+mtproxy/cli.py,sha256=TE5wm94dvR_lGd8gVNnG37aIuBx-QlB7TMloSTp4FDo,5238
+mtproxy/config.py,sha256=CP8_8vpd27hCphfxAlT1uRlbXMHhSgi4c2m3qCVLCoc,6163
+mtproxy/daemon.py,sha256=6jTfTD_SX5JGOSamBj8vQubnWPyAmBSv7l4tCQ6FRVc,6142
+mtproxy/logger.py,sha256=vD24MnplywJtPVPkmdRXjZTL4uOeXzy2HEmVYH-afqs,3151
+mtproxy/server.py,sha256=jtbwgItjv9upMC6bJMutmumCOSjeZeGyhsLgqCsQt_o,8978
+mtproxy/stats.py,sha256=Py4GvrVmJIqHlVDAYq0fP-J7KmO4PI4BZMBmci2R1mA,6843
+py_mtproxy_lib-0.0.1.dist-info/METADATA,sha256=OwZskjBISvQtk5jhk7F_AYeJpvREMoezN9y3V6OnalY,1794
+py_mtproxy_lib-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+py_mtproxy_lib-0.0.1.dist-info/entry_points.txt,sha256=e0nc73vMvyxlBqZe6oWveRE26zl3emQWvKTgJ80Oqx0,45
+py_mtproxy_lib-0.0.1.dist-info/top_level.txt,sha256=rOXQuaO2tvbsxQIRbvoBcoDB9wAOMMuvGDg24eYPqhc,8
+py_mtproxy_lib-0.0.1.dist-info/RECORD,,

py_mtproxy_lib-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py_mtproxy_lib-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mtproxy = mtproxy.cli:main

py_mtproxy_lib-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mtproxy