mtproto 0.0.4 → 0.0.6

data/lib/mtproto/client.rb

@@ -1,36 +1,52 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+require 'digest'
 require_relative 'transport/tcp_connection'
 require_relative 'transport/abridged_packet_codec'
 require_relative 'tl/message'
 
 module MTProto
   class Client
-    DC_ADDRESSES = {
-      1 => ['149.154.175.50', 443],
-      2 => ['149.154.167.51', 443],
-      3 => ['149.154.175.100', 443],
-      4 => ['149.154.167.91', 443],
-      5 => ['91.108.56.130', 443]
-    }.freeze
+    attr_reader :connection, :server_key, :auth_key, :server_salt, :time_offset, :session, :timeout
+    attr_accessor :api_id, :api_hash, :device_model, :system_version, :app_version, :system_lang_code, :lang_pack, :lang_code
 
-    attr_reader :connection
+    CONSTRUCTOR_MSGS_ACK = 0x62d6b459
 
-    def initialize(dc_id: 2)
-      host, port = DC_ADDRESSES[dc_id]
-      raise ArgumentError, "Unknown DC ID: #{dc_id}" unless host
+    def initialize(api_id: nil, api_hash: nil, host:, port: 443, public_key: nil, dc_number: nil, test_mode: false, timeout: 10)
+      raise ArgumentError, "host is required" if host.nil? || host.empty?
+      raise ArgumentError, "dc_number must be positive. Use test_mode: true for test DCs" if dc_number && dc_number < 0
 
       codec = Transport::AbridgedPacketCodec.new
       @connection = Transport::TCPConnection.new(host, port, codec)
+      @public_key = public_key
+      @dc_number = dc_number
+      @test_mode = test_mode
+      @timeout = timeout
+      @server_key = nil
+      @auth_key = nil
+      @server_salt = nil
+      @time_offset = 0
+      @session = nil
+      @connection_initialized = false
+
+      # Client configuration defaults
+      @api_id = api_id || 0
+      @api_hash = api_hash || ''
+      @device_model = 'Ruby MTProto'
+      @system_version = RUBY_DESCRIPTION
+      @app_version = '0.1.0'
+      @system_lang_code = 'en'
+      @lang_pack = ''
+      @lang_code = 'en'
     end
 
-    def connect
-      @connection.connect
+    def connect!
+      @connection.connect!
     end
 
-    def disconnect
-      @connection.close
+    def disconnect!
+      @connection.close if @connection
     end
 
     def req_pq_multi
@@ -41,18 +57,199 @@ module MTProto
 
       @connection.send(payload)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
 
       res_pq = response_message.parse_res_pq
 
       raise 'Nonce mismatch!' unless res_pq[:nonce] == nonce
 
-      rsa_key = Crypto::RSAKey.find_by_fingerprint(res_pq[:fingerprints])
-      raise 'No matching RSA key found!' unless rsa_key
-
-      res_pq[:rsa_key] = rsa_key
       res_pq
     end
+
+    def make_auth_key
+      raise ArgumentError, "public_key is required for auth key generation" if @public_key.nil? || @public_key.empty?
+
+      generator = AuthKeyGenerator.new(@connection, @public_key, @dc_number, test_mode: @test_mode, timeout: @timeout)
+      result = generator.generate
+
+      @auth_key = generator.auth_key
+      @server_salt = generator.server_salt
+      @time_offset = generator.time_offset
+      @session = Session.new
+
+      result
+    end
+
+    def generate_msg_id
+      time = Time.now.to_f + @time_offset
+      msg_id = (time * (2**32)).to_i
+      (msg_id / 4) * 4
+    end
+
+    def rpc_call(body, content_related: true)
+      raise 'Auth key not generated' unless @auth_key
+      raise 'Session not initialized' unless @session
+
+      msg_id = generate_msg_id
+      seq_no = @session.next_seq_no(content_related: content_related)
+
+      encrypted_msg = EncryptedMessage.encrypt(
+        auth_key: @auth_key,
+        server_salt: @server_salt,
+        session_id: @session.session_id,
+        msg_id: msg_id,
+        seq_no: seq_no,
+        body: body
+      )
+
+      @connection.send(encrypted_msg.serialize)
+
+      response_data = @connection.recv(timeout: @timeout)
+
+      decrypted = EncryptedMessage.decrypt(
+        auth_key: @auth_key,
+        encrypted_message_data: response_data,
+        sender: :server
+      )
+
+      response_body = decrypted[:body]
+
+      constructor = response_body[0, 4].unpack1('L<')
+
+      if constructor == TL::NewSessionCreated::CONSTRUCTOR
+        session_info = TL::NewSessionCreated.deserialize(response_body)
+        @server_salt = session_info.server_salt
+
+        response_data = @connection.recv(timeout: @timeout)
+        decrypted = EncryptedMessage.decrypt(
+          auth_key: @auth_key,
+          encrypted_message_data: response_data,
+          sender: :server
+        )
+        response_body = decrypted[:body]
+        constructor = response_body[0, 4].unpack1('L<')
+      end
+
+      if constructor == TL::Message::CONSTRUCTOR_MSG_CONTAINER
+        container = TL::MsgContainer.deserialize(response_body)
+
+        rpc_result = container.messages.find do |msg|
+          msg[:body][0, 4].unpack1('L<') == 0xf35c6d01
+        end
+
+        return rpc_result[:body][12..] if rpc_result
+
+        new_session = container.messages.find { |msg| msg[:body][0, 4].unpack1('L<') == TL::NewSessionCreated::CONSTRUCTOR }
+        if new_session
+          session_info = TL::NewSessionCreated.deserialize(new_session[:body])
+          @server_salt = session_info.server_salt
+
+          other_messages = container.messages.reject do |msg|
+            constructor = msg[:body][0, 4].unpack1('L<')
+            constructor == TL::NewSessionCreated::CONSTRUCTOR || constructor == CONSTRUCTOR_MSGS_ACK
+          end
+
+          if !other_messages.empty?
+            return other_messages.first[:body]
+          end
+
+          response_data = @connection.recv(timeout: @timeout)
+          decrypted = EncryptedMessage.decrypt(
+            auth_key: @auth_key,
+            encrypted_message_data: response_data,
+            sender: :server
+          )
+          response_body = decrypted[:body]
+          constructor = response_body[0, 4].unpack1('L<')
+
+          return response_body[12..] if constructor == 0xf35c6d01
+
+          if constructor == TL::Message::CONSTRUCTOR_MSG_CONTAINER
+            container = TL::MsgContainer.deserialize(response_body)
+            rpc_result = container.messages.find { |msg| msg[:body][0, 4].unpack1('L<') == 0xf35c6d01 }
+            return rpc_result[:body][12..] if rpc_result
+          end
+
+          return response_body
+        end
+
+        return container.messages.first[:body]
+      end
+
+      return response_body[12..] if constructor == 0xf35c6d01
+
+      response_body
+    end
+
+    def invoke_with_layer(layer, query)
+      body = TL::Serializer.serialize_int(0xda9b0d0d)
+      body += TL::Serializer.serialize_int(layer)
+      body += query
+      body
+    end
+
+    def init_connection(api_id:, device_model:, system_version:, app_version:, system_lang_code:, lang_pack:, lang_code:, query:)
+      body = TL::Serializer.serialize_int(0xc1cd5ea9)
+      flags = 0
+      body += TL::Serializer.serialize_int(flags)
+      body += TL::Serializer.serialize_int(api_id)
+      body += TL::Serializer.serialize_string(device_model)
+      body += TL::Serializer.serialize_string(system_version)
+      body += TL::Serializer.serialize_string(app_version)
+      body += TL::Serializer.serialize_string(system_lang_code)
+      body += TL::Serializer.serialize_string(lang_pack)
+      body += TL::Serializer.serialize_string(lang_code)
+      body += query
+      body
+    end
+
+    def help_get_config
+      query = [0xc4f9186b].pack('L<')
+
+      unless @connection_initialized
+        query = init_connection(
+          api_id: @api_id,
+          device_model: @device_model,
+          system_version: @system_version,
+          app_version: @app_version,
+          system_lang_code: @system_lang_code,
+          lang_pack: @lang_pack,
+          lang_code: @lang_code,
+          query: query
+        )
+        query = invoke_with_layer(214, query)
+        @connection_initialized = true
+      end
+
+      rpc_call(query)
+    end
+
+    def auth_send_code(phone_number, code_settings: {})
+      raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+
+      query = [0xa677244f].pack('L<')
+      query += TL::Serializer.serialize_string(phone_number)
+      query += TL::Serializer.serialize_int(@api_id)
+      query += TL::Serializer.serialize_string(@api_hash)
+      query += TL::CodeSettings.serialize(code_settings)
+
+      unless @connection_initialized
+        query = init_connection(
+          api_id: @api_id,
+          device_model: @device_model,
+          system_version: @system_version,
+          app_version: @app_version,
+          system_lang_code: @system_lang_code,
+          lang_pack: @lang_pack,
+          lang_code: @lang_code,
+          query: query
+        )
+        query = invoke_with_layer(214, query)
+        @connection_initialized = true
+      end
+
+      rpc_call(query)
+    end
   end
 end

data/lib/mtproto/connection.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module MTProto
+  class Connection
+    attr_reader :client
+
+    def initialize(api_id: nil, api_hash: nil, host:, port: 443, public_key:, dc_number:, test_mode: false, timeout: 10)
+      @client = Client.new(
+        api_id: api_id,
+        api_hash: api_hash,
+        host: host,
+        port: port,
+        public_key: public_key,
+        dc_number: dc_number,
+        test_mode: test_mode,
+        timeout: timeout
+      )
+      @connected = false
+    end
+
+    def connect!
+      return if @connected
+
+      @client.connect!
+      @client.make_auth_key
+      @connected = true
+    end
+
+    def disconnect!
+      @client.disconnect! if @connected
+      @connected = false
+    end
+
+    def ping(ping_id = nil)
+      raise NotConnectedError unless @connected
+
+      ping_id ||= rand(2**63)
+      body = TL::Message.ping(ping_id)
+
+      response_body = @client.rpc_call(body)
+      message = TL::Message.new(body: response_body)
+      pong = message.parse_pong
+
+      raise PingMismatchError unless pong[:ping_id] == ping_id
+
+      true
+    end
+
+    def get_config
+      raise NotConnectedError unless @connected
+
+      response = @client.help_get_config
+
+      # Handle gzip compression
+      constructor = response[0, 4].unpack1('L<')
+      if constructor == TL::GzipPacked::CONSTRUCTOR
+        response = TL::GzipPacked.unpack(response)
+        constructor = response[0, 4].unpack1('L<')
+      end
+
+      # Handle RPC errors
+      if constructor == TL::RpcError::CONSTRUCTOR
+        error = TL::RpcError.deserialize(response)
+        raise MTProto::RpcError.new(error.error_code, error.error_message)
+      end
+
+      # Parse and return config
+      if constructor == TL::Config::CONSTRUCTOR || constructor == TL::Config::CONSTRUCTOR_ALT
+        TL::Config.deserialize(response)
+      else
+        raise UnexpectedConstructorError.new(constructor)
+      end
+    end
+
+    def send_code(phone_number, code_settings: {})
+      raise NotConnectedError unless @connected
+      raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+
+      response = @client.auth_send_code(phone_number, code_settings: code_settings)
+
+      # Handle gzip compression
+      constructor = response[0, 4].unpack1('L<')
+      if constructor == TL::GzipPacked::CONSTRUCTOR
+        response = TL::GzipPacked.unpack(response)
+        constructor = response[0, 4].unpack1('L<')
+      end
+
+      # Handle RPC errors
+      if constructor == TL::RpcError::CONSTRUCTOR
+        error = TL::RpcError.deserialize(response)
+        raise MTProto::RpcError.new(error.error_code, error.error_message)
+      end
+
+      # Parse and return sent code
+      if constructor == TL::SentCode::CONSTRUCTOR
+        sent_code = TL::SentCode.deserialize(response)
+        sent_code.to_h
+      else
+        raise UnexpectedConstructorError.new(constructor)
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/aes_ige.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+begin
+  require 'aes_ige/aes_ige'
+rescue LoadError => e
+  warn "Failed to load AES-IGE C extension: #{e.message}"
+  warn 'Run: cd ext/aes_ige && ruby extconf.rb && make'
+  warn 'AES-IGE encryption/decryption will not be available'
+
+  module MTProto
+    module Crypto
+      module AES_IGE
+        def self.encrypt_ige(_plaintext, _key, _iv)
+          raise NotImplementedError, 'AES-IGE not available (C extension not loaded)'
+        end
+
+        def self.decrypt_ige(_ciphertext, _key, _iv)
+          raise NotImplementedError, 'AES-IGE not available (C extension not loaded)'
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/auth_key_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module MTProto
+  module Crypto
+    module AuthKeyHelper
+      module_function
+
+      def derive_tmp_aes_key(new_nonce, server_nonce)
+        sha1_a = Digest::SHA1.digest(new_nonce + server_nonce)
+        sha1_b = Digest::SHA1.digest(server_nonce + new_nonce)
+
+        sha1_a + sha1_b[0, 12]
+      end
+
+      def derive_tmp_aes_iv(new_nonce, server_nonce)
+        sha1_b = Digest::SHA1.digest(server_nonce + new_nonce)
+        sha1_c = Digest::SHA1.digest(new_nonce + new_nonce)
+
+        sha1_b[12, 8] + sha1_c + new_nonce[0, 4]
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/dh_key_exchange.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'securerandom'
+
+module MTProto
+  module Crypto
+    module DHKeyExchange
+      module_function
+
+      def generate_client_dh_params(g, dh_prime_bytes)
+        dh_prime = OpenSSL::BN.new(dh_prime_bytes, 2)
+        g_bn = OpenSSL::BN.new(g)
+
+        b = generate_random_2048_bit_number
+        g_b = g_bn.mod_exp(b, dh_prime)
+
+        DHValidator.validate_g_a(g_b, dh_prime)
+
+        {
+          b: b,
+          g_b: g_b,
+          g_b_bytes: g_b.to_s(2)
+        }
+      end
+
+      def compute_auth_key(g_a_bytes, b, dh_prime_bytes)
+        g_a = OpenSSL::BN.new(g_a_bytes, 2)
+        dh_prime = OpenSSL::BN.new(dh_prime_bytes, 2)
+
+        auth_key_bn = g_a.mod_exp(b, dh_prime)
+        auth_key_bn.to_s(2)
+      end
+
+      def generate_random_2048_bit_number
+        random_bytes = SecureRandom.random_bytes(256)
+        random_bytes[0] = (random_bytes[0].ord | 0x80).chr
+
+        bn = OpenSSL::BN.new(random_bytes, 2)
+        bn
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/dh_validator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module MTProto
+  module Crypto
+    module DHValidator
+      module_function
+
+      def validate_dh_params(g, dh_prime_bytes, g_a_bytes)
+        dh_prime = OpenSSL::BN.new(dh_prime_bytes, 2)
+        g_a = OpenSSL::BN.new(g_a_bytes, 2)
+
+        validate_g(g, dh_prime)
+        validate_dh_prime(dh_prime)
+        validate_g_a(g_a, dh_prime)
+
+        true
+      end
+
+      def validate_g(g, dh_prime)
+        raise 'Invalid g: must be 2, 3, 4, 5, 6, or 7' unless [2, 3, 4, 5, 6, 7].include?(g)
+
+        p_mod = case g
+        when 2
+          dh_prime % 8 == 7
+        when 3
+          dh_prime % 3 == 2
+        when 4
+          true
+        when 5
+          mod5 = dh_prime % 5
+          mod5 == 1 || mod5 == 4
+        when 6
+          mod24 = dh_prime % 24
+          mod24 == 19 || mod24 == 23
+        when 7
+          mod7 = dh_prime % 7
+          [3, 5, 6].include?(mod7)
+        end
+
+        raise "g=#{g} is not a valid generator for this prime" unless p_mod
+
+        true
+      end
+
+      def validate_dh_prime(dh_prime)
+        bit_length = dh_prime.num_bits
+
+        raise 'dh_prime must be 2048 bits' unless bit_length == 2048
+
+        min_prime = OpenSSL::BN.new(2)**2047
+        max_prime = OpenSSL::BN.new(2)**2048
+
+        if dh_prime <= min_prime || dh_prime >= max_prime
+          raise 'dh_prime out of range (must be 2^2047 < p < 2^2048)'
+        end
+
+        true
+      end
+
+      def validate_g_a(g_a, dh_prime)
+        one = OpenSSL::BN.new(1)
+        dh_prime_minus_one = dh_prime - one
+
+        raise 'g_a must be > 1' if g_a <= one
+        raise 'g_a must be < dh_prime - 1' if g_a >= dh_prime_minus_one
+
+        safety_range_min = OpenSSL::BN.new(2)**1984
+        safety_range_max = dh_prime - safety_range_min
+
+        if g_a < safety_range_min || g_a > safety_range_max
+          raise 'g_a outside safety range (2^1984 to dh_prime - 2^1984)'
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/factorization.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+begin
+  require 'factorization/factorization'
+rescue LoadError => e
+  warn "Failed to load Factorization C extension: #{e.message}"
+  warn 'Run: cd ext/factorization && ruby extconf.rb && make'
+  raise
+end
+
+module MTProto
+  module Crypto
+    module Factorization
+      module_function
+
+      def factorize_pq(pq_bytes)
+        FactorizationExt.factorize_pq(pq_bytes)
+      end
+
+      def bytes_to_integer(bytes)
+        bytes.unpack('C*').inject(0) { |sum, byte| (sum << 8) | byte }
+      end
+
+      def integer_sqrt(n)
+        return n if n < 2
+
+        x = n
+        y = (x + 1) / 2
+
+        while y < x
+          x = y
+          y = (x + n / x) / 2
+        end
+
+        x
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/message_key.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module MTProto
+  module Crypto
+    module MessageKey
+      module_function
+
+      def generate_msg_key(auth_key, plaintext, sender: :client)
+        x = sender == :client ? 0 : 8
+        auth_key_part = auth_key[88 + x, 32]
+
+        sha256_a = Digest::SHA256.digest(auth_key_part + plaintext)
+
+        sha256_a[8, 16]
+      end
+
+      def derive_aes_key_iv(auth_key, msg_key, sender: :client)
+        x = sender == :client ? 0 : 8
+
+        sha256_a = Digest::SHA256.digest(msg_key + auth_key[x, 36])
+        sha256_b = Digest::SHA256.digest(auth_key[40 + x, 36] + msg_key)
+
+        aes_key = sha256_a[0, 8] + sha256_b[8, 16] + sha256_a[24, 8]
+        aes_iv = sha256_b[0, 8] + sha256_a[8, 16] + sha256_b[24, 8]
+
+        { aes_key: aes_key, aes_iv: aes_iv }
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/rsa_key.rb

@@ -6,30 +6,24 @@ require 'digest'
 module MTProto
   module Crypto
     class RSAKey
-      TELEGRAM_KEY = <<~PEM
-        -----BEGIN RSA PUBLIC KEY-----
-        MIIBCgKCAQEA6LszBcC1LGzyr992NzE0ieY+BSaOW622Aa9Bd4ZHLl+TuFQ4lo4g
-        5nKaMBwK/BIb9xUfg0Q29/2mgIR6Zr9krM7HjuIcCzFvDtr+L0GQjae9H0pRB2OO
-        62cECs5HKhT5DZ98K33vmWiLowc621dQuwKWSQKjWf50XYFw42h21P2KXUGyp2y/
-        +aEyZ+uVgLLQbRA1dEjSDZ2iGRy12Mk5gpYc397aYp438fsJoHIgJ2lgMv5h7WY9
-        t6N/byY9Nw9p21Og3AoXSL2q/2IJ1WRUhebgAdGVMlV1fkuOQoEzR7EdpqtQD9Cs
-        5+bfo3Nhmcyvk5ftB0WkJ9z6bNZ7yxrP8wIDAQAB
-        -----END RSA PUBLIC KEY-----
-      PEM
-
       attr_reader :key, :fingerprint
 
       def initialize(pem_string)
+        raise ArgumentError, "pem_string is required" if pem_string.nil? || pem_string.empty?
+
         @key = OpenSSL::PKey::RSA.new(pem_string)
         @fingerprint = calculate_fingerprint
       end
 
-      def self.telegram_key
-        @telegram_key ||= new(TELEGRAM_KEY)
+      def self.from_pem(pem_string)
+        new(pem_string)
       end
 
-      def self.find_by_fingerprint(fingerprints)
-        telegram_key if fingerprints.include?(telegram_key.fingerprint)
+      def self.find_by_fingerprint(fingerprints, public_key)
+        raise ArgumentError, "public_key is required" if public_key.nil? || public_key.empty?
+
+        key = new(public_key)
+        key if fingerprints.include?(key.fingerprint)
       end
 
       private