Stable async proxy

Author: Yurzs

AESEncryptor.py

@@ -0,0 +1,5 @@
+telegram_ips = [ "149.154.175.50", "149.154.167.51", "149.154.175.100", "149.154.167.91", "149.154.171.5"]
+mtproto_footprint = b'\xef\xef\xef\xef'
+obf_footprint = b'\xdd\xdd\xdd\xdd'
+secret = '1234567890abc1234567890abcef1234'
+

Core.py

@@ -0,0 +1,34 @@
+from encryption.crypto import Encryptor, Decryptor
+from config import secret, telegram_ips, mtproto_footprint, obf_footprint
+from exceptions import WrongServerID
+from protocols.telegram import TelegramProtocol
+
+
+class Dispatcher:
+    def __init__(self, loop, real_protocol):
+        self.loop = loop
+        self.real_protocol = real_protocol
+        self.telegram_protocol = None
+        self.telegram_transport = None
+        self.encryptor = None
+        self.decryptor = None
+
+    async def handle(self, raw_data: bytes):
+        if not self.encryptor or not self.decryptor:
+            self.decryptor = Decryptor(raw_data, secret)
+            self.encryptor = Encryptor(raw_data, secret)
+            self.decoded_data = await self.decryptor(raw_data)
+            server_id = int.from_bytes(self.decoded_data[60:62], 'little') - 1
+            if server_id < 0 or server_id > len(telegram_ips):
+                raise WrongServerID(f'Got id {server_id}')
+            self.telegram_server_ip = telegram_ips[server_id]
+            assert self.decoded_data[56:60] == mtproto_footprint or self.decoded_data[56:60] == obf_footprint, self.decoded_data[56:60]
+        if not self.telegram_protocol or not self.telegram_transport:
+            self.telegram_transport, self.telegram_protocol = await self.loop.create_connection(lambda: TelegramProtocol(self.loop, self),
+                self.telegram_server_ip, 443)
+            self.telegram_transport.write(self.decoded_data)
+            return
+        self.telegram_transport.write(await self.decryptor(raw_data))
+
+    async def reverse_handle(self, raw_data):
+        self.real_protocol.transport.write(await self.encryptor(raw_data))

MTProtoPacket.py

@@ -0,0 +1,15 @@
+import pyaes
+
+class AES_CTR:
+    def __init__(self, key, iv):
+        assert isinstance(key, bytes), 'Key should be instance of bytes'
+        self._aes = pyaes.AESModeOfOperationCTR(key)
+        assert isinstance(iv, bytes), 'IV should be instance of bytes'
+        assert len(iv) == 16, 'IV length must be 16 bytes'
+        self._aes._counter._counter = list(iv)
+
+    async def encrypt(self, data):
+        return self._aes.encrypt(data)
+
+    async def decrypt(self, data):
+        return self._aes.decrypt(data)

config.py

@@ -0,0 +1,45 @@
+from hashlib import sha256
+
+from .aes import AES_CTR
+
+
+class DecryptionKey:
+    def __init__(self, key, secret):
+        dec_key = sha256()
+        dec_key.update(key)
+        dec_key.update(secret)
+        self.key = dec_key.digest()
+
+    def __call__(self):
+        return self.key
+
+
+class EncryptionKey:
+    def __init__(self, key, secret):
+        enc_key = sha256()
+        enc_key.update(key)
+        enc_key.update(secret)
+        self.key = enc_key.digest()
+
+    def __call__(self):
+        return self.key
+
+
+class Decryptor:
+    def __init__(self, raw_bytes, secret):
+        self.secret = bytes.fromhex(secret)
+        self.decryption_key = DecryptionKey(raw_bytes[8:40], self.secret)
+        self.aes = AES_CTR(self.decryption_key(), raw_bytes[40:56])
+
+    async def __call__(self, data):
+        return await self.aes.decrypt(data)
+
+
+class Encryptor:
+    def __init__(self, raw_bytes, secret):
+        self.secret = bytes.fromhex(secret)
+        self.encryption_key = EncryptionKey(raw_bytes[8:56][::-1][0:32], self.secret)
+        self.aes = AES_CTR(self.encryption_key(), raw_bytes[8:56][::-1][32:48])
+
+    async def __call__(self, data):
+        return await self.aes.encrypt(data)

pymtproxy/config.py

@@ -0,0 +1,8 @@
+
+
+class ProxyBaseException(Exception):
+    pass
+
+
+class WrongServerID(ProxyBaseException):
+    pass

pymtproxy/dispatcher.py

@@ -0,0 +1,2 @@
+from .real import RealProtocol
+from .telegram import TelegramProtocol