py-mtproxy-lib 0.0.2__tar.gz → 0.0.4__tar.gz

{py_mtproxy_lib-0.0.2 → py_mtproxy_lib-0.0.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: py-mtproxy-lib
-Version: 0.0.2
+Version: 0.0.4
 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: AneK
 Author-email: tashova28@gmail.com
 Project-URL: Bug Reports, https://github.com/twosleepynights0x1/py-mtproxy-lib
 Keywords: mtproto telegram proxy vpn daemon docker

{py_mtproxy_lib-0.0.2 → py_mtproxy_lib-0.0.4}/mtproxy/cli.py

@@ -1,18 +1,14 @@
-"""CLI интерфейс"""
-
 import argparse
 import sys
 import os
 from .config import ProxyConfig
 from .server import MTProxyServer
-from .utils import generate_secret
+from .utils import generate_secret, find_free_port, get_public_ip, get_common_ports
 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
@@ -32,7 +28,6 @@ def start_server(config: ProxyConfig, foreground: bool = False):
 
 
 def main():
-    """Основная функция CLI"""
     parser = argparse.ArgumentParser(
         description="MTProto Proxy Server",
         prog="mtproxy"
@@ -53,10 +48,16 @@ def main():
     
     parser.add_argument(
         "-p", "--port",
-        help="Port to listen on",
+        help="Port to listen on (auto-find if not specified)",
         type=int
     )
     
+    parser.add_argument(
+        "--auto-port",
+        help="Automatically find free port",
+        action="store_true"
+    )
+    
     parser.add_argument(
         "--no-fake-tls",
         help="Disable Fake TLS masking",
@@ -106,9 +107,21 @@ def main():
         action="store_true"
     )
     
-    # Команды управления демоном
-    subparsers = parser.add_subparsers(dest="command", help="Daemon commands")
+    parser.add_argument(
+        "--show-ip",
+        help="Show public IP address",
+        action="store_true"
+    )
     
+    parser.add_argument(
+        "--find-port",
+        help="Find free port in range",
+        type=str,
+        nargs='?',
+        const="5000-10000"
+    )
+    
+    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")
@@ -116,12 +129,27 @@ def main():
     
     args = parser.parse_args()
     
-    # Генерация секрета
     if args.generate_secret:
         print(generate_secret())
         sys.exit(0)
     
-    # Загрузка конфигурации
+    if args.show_ip:
+        ip = get_public_ip()
+        print(ip if ip else "Could not detect public IP")
+        sys.exit(0)
+    
+    if args.find_port:
+        try:
+            if '-' in args.find_port:
+                start, end = map(int, args.find_port.split('-'))
+            else:
+                start, end = 5000, 10000
+            port = find_free_port(start, end)
+            print(f"Free port found: {port}")
+        except Exception as e:
+            print(f"Error: {e}")
+        sys.exit(0)
+    
     config = None
     if os.path.exists(args.config):
         try:
@@ -132,9 +160,16 @@ def main():
     if not config:
         config = ProxyConfig()
     
-    # Применение CLI аргументов
     if args.port:
         config.port = args.port
+    elif args.auto_port or not config.port:
+        try:
+            config.port = find_free_port(5000, 10000, get_common_ports())
+            print(f"Auto-selected free port: {config.port}")
+        except Exception as e:
+            print(f"Error finding free port: {e}", file=sys.stderr)
+            sys.exit(1)
+    
     if args.no_fake_tls:
         config.enable_fake_tls = False
     if args.pid_file:
@@ -146,25 +181,27 @@ def main():
     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()
+        from .utils import get_public_ip
+        ip = get_public_ip() or "YOUR_SERVER_IP"
+        print(f"Server IP: {ip}")
+        print(f"Port: {config.port}")
         print("Connection links:")
-        for name, link in links.items():
-            print(f"  {name}: {link}")
+        for secret, tag in config.secrets.items():
+            link = f"tg://proxy?server={ip}&port={config.port}&secret={secret}"
+            if tag:
+                link += f"&tag={tag}"
+            print(f"  {link}")
         sys.exit(0)
     
-    # Команды демона
     daemon = Daemon(
         pidfile=config.pid_file or '/var/run/mtproxy.pid',
         stdout=config.log_file or '/dev/null',
@@ -181,7 +218,6 @@ def main():
         print(daemon.status())
         sys.exit(0)
     
-    # Запуск в foreground или daemon
     if args.daemon:
         daemon.start(start_server, config)
     else:

{py_mtproxy_lib-0.0.2 → py_mtproxy_lib-0.0.4}/mtproxy/server.py

@@ -1,28 +1,17 @@
-"""Основной класс MTProto прокси сервера"""
-
 import asyncio
 import uuid
 import signal
 import time
-from typing import Optional, Dict, Callable
+from typing import Optional, Dict
 from .config import ProxyConfig
 from .stats import ProxyStats
 from .logger import get_logger
-from .utils import verify_fake_tls_handshake, get_external_ip
+from .utils import get_external_ip, get_public_ip
 
 
 class MTProxyServer:
-    """
-    MTProto прокси сервер с поддержкой нескольких секретов и статистики
-    """
     
     def __init__(self, config: ProxyConfig):
-        """
-        Инициализация прокси сервера
-        
-        Args:
-            config: Конфигурация прокси
-        """
         self.config = config
         self.logger = get_logger()
         self.stats = ProxyStats()
@@ -32,22 +21,30 @@ class MTProxyServer:
         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
-    ):
-        """Обработка входящего подключения"""
+    def get_connection_link(self, custom_ip: str = None) -> str:
+        ip = custom_ip or get_public_ip() or get_external_ip() or "YOUR_SERVER_IP"
+        secret = list(self.config.secrets.keys())[0] if self.config.secrets else ""
+        return f"tg://proxy?server={ip}&port={self.config.port}&secret={secret}"
+    
+    def get_all_links(self, custom_ip: str = None) -> Dict[str, str]:
+        ip = custom_ip or get_public_ip() or get_external_ip() or "YOUR_SERVER_IP"
+        links = {}
+        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}"
+            links[secret[:16] + ("..." if len(secret) > 16 else "")] = link
+        return links
+    
+    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
@@ -57,15 +54,20 @@ class MTProxyServer:
                 writer.close()
                 return
             
-            # Аутентификация с несколькими секретами
             if self.config.enable_fake_tls and handshake[0] == 0x16:
-                success, secret = self.config.verify_secret(handshake)
+                from .utils import verify_fake_tls_handshake
+                success, secret = False, None
+                for secret_hex, tag in self.config.secrets.items():
+                    secret_bytes = bytes.fromhex(secret_hex)
+                    if verify_fake_tls_handshake(handshake, secret_bytes):
+                        success = True
+                        secret = secret_hex
+                        break
                 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()
@@ -76,19 +78,14 @@ class MTProxyServer:
                     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)
             )
@@ -99,7 +96,6 @@ class MTProxyServer:
             self._tasks[conn_id] = task_client
             self._tasks[f"{conn_id}_server"] = task_server
             
-            # Ожидание завершения
             await asyncio.gather(task_client, task_server)
             
         except asyncio.TimeoutError:
@@ -109,10 +105,8 @@ class MTProxyServer:
         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()
@@ -120,18 +114,10 @@ class MTProxyServer:
             
             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
-    ):
-        """Пересылка данных с обновлением статистики"""
+    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)
@@ -141,7 +127,6 @@ class MTProxyServer:
                 writer.write(data)
                 await writer.drain()
                 
-                # Обновление статистики
                 if sent:
                     self.stats.update_bytes(conn_id, sent=len(data))
                 if received:
@@ -155,20 +140,17 @@ class MTProxyServer:
             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,
@@ -177,10 +159,8 @@ class MTProxyServer:
                 )
             )
             
-            # Запуск репортера статистики
             stats_task = loop.create_task(self._stats_reporter())
             
-            # Вывод информации
             print("=" * 60)
             print("🚀 MTProxy Server Started")
             print("=" * 60)
@@ -191,18 +171,14 @@ class MTProxyServer:
             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}"
+            links = self.get_all_links()
+            for name, link in links.items():
                 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()))
             
@@ -220,11 +196,9 @@ class MTProxyServer:
             loop.close()
     
     async def stop(self):
-        """Остановка сервера"""
         self.logger.info("Shutting down...")
         self._running = False
         
-        # Отмена всех задач
         for task in self._tasks.values():
             task.cancel()
         

py_mtproxy_lib-0.0.4/mtproxy/utils.py

@@ -0,0 +1,96 @@
+"""Вспомогательные функции"""
+
+import secrets
+import hashlib
+import hmac
+from typing import Optional, List
+import urllib.request
+import socket
+
+
+def generate_secret() -> str:
+    return secrets.token_hex(16)
+
+
+def verify_fake_tls_handshake(data: bytes, secret: bytes) -> bool:
+    if not data or len(data) < 51 or data[0] != 0x16:
+        return False
+    
+    digest = data[11:43]
+    timestamp = data[43:51]
+    expected = hmac.new(secret, timestamp, hashlib.sha256).digest()[:32]
+    
+    return hmac.compare_digest(digest, expected)
+
+
+def get_external_ip() -> Optional[str]:
+    try:
+        with urllib.request.urlopen('https://ifconfig.me', timeout=5) as response:
+            return response.read().decode('utf-8').strip()
+    except Exception:
+        return None
+
+
+def find_free_port(start_port: int = 5000, end_port: int = 10000, exclude_ports: List[int] = None) -> int:
+    if exclude_ports is None:
+        exclude_ports = []
+    
+    for port in range(start_port, end_port + 1):
+        if port in exclude_ports:
+            continue
+            
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(1)
+        result = sock.connect_ex(('127.0.0.1', port))
+        sock.close()
+        
+        if result != 0:
+            return port
+    
+    raise RuntimeError(f"No free port found in range {start_port}-{end_port}")
+
+
+def get_public_ip() -> Optional[str]:
+    services = [
+        'https://ifconfig.me',
+        'https://api.ipify.org',
+        'https://icanhazip.com',
+        'https://checkip.amazonaws.com'
+    ]
+    
+    for service in services:
+        try:
+            with urllib.request.urlopen(service, timeout=5) as response:
+                ip = response.read().decode('utf-8').strip()
+                if ip:
+                    return ip
+        except Exception:
+            continue
+    
+    return None
+
+
+def get_local_ip() -> str:
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(('8.8.8.8', 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return '127.0.0.1'
+
+
+def check_port_available(port: int, host: str = '0.0.0.0') -> bool:
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(1)
+        result = sock.connect_ex((host, port))
+        sock.close()
+        return result != 0
+    except Exception:
+        return False
+
+
+def get_common_ports() -> List[int]:
+    return [443, 8443, 8080, 5001, 5047, 5050, 8081, 9443, 2053, 2096, 2087, 2083]

{py_mtproxy_lib-0.0.2 → py_mtproxy_lib-0.0.4}/py_mtproxy_lib.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: py-mtproxy-lib
-Version: 0.0.2
+Version: 0.0.4
 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: AneK
 Author-email: tashova28@gmail.com
 Project-URL: Bug Reports, https://github.com/twosleepynights0x1/py-mtproxy-lib
 Keywords: mtproto telegram proxy vpn daemon docker

{py_mtproxy_lib-0.0.2 → py_mtproxy_lib-0.0.4}/py_mtproxy_lib.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ mtproxy/daemon.py
 mtproxy/logger.py
 mtproxy/server.py
 mtproxy/stats.py
+mtproxy/utils.py
 py_mtproxy_lib.egg-info/PKG-INFO
 py_mtproxy_lib.egg-info/SOURCES.txt
 py_mtproxy_lib.egg-info/dependency_links.txt

{py_mtproxy_lib-0.0.2 → py_mtproxy_lib-0.0.4}/setup.py

@@ -5,8 +5,8 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="py-mtproxy-lib",
-    version="0.0.2",
-    author="Your Name",
+    version="0.0.4",
+    author="AneK",
     author_email="tashova28@gmail.com",
     description="Production-ready MTProto proxy server library with multi-secret support, statistics, and daemon mode",
     long_description=long_description,