mtproto 0.0.6 → 0.0.8

data/lib/mtproto/client.rb

@@ -2,16 +2,21 @@
 
 require 'securerandom'
 require 'digest'
+require 'base64'
 require_relative 'transport/tcp_connection'
 require_relative 'transport/abridged_packet_codec'
-require_relative 'tl/message'
+require_relative 'type/message'
+require_relative 'client/rpc'
+require_relative 'type/rpc/help/get_config'
+require_relative 'type/rpc/help/config'
+require_relative 'type/rpc/invoke_with_layer'
+require_relative 'type/rpc/init_connection'
 
 module MTProto
   class Client
-    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
 
-    CONSTRUCTOR_MSGS_ACK = 0x62d6b459
+    attr_reader :connection, :server_key, :auth_key, :server_salt, :time_offset, :session, :timeout, :user_id, :access_hash, :dc_number
+    attr_accessor :api_id, :api_hash, :device_model, :system_version, :app_version, :system_lang_code, :lang_pack, :lang_code
 
     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?
@@ -29,6 +34,8 @@ module MTProto
       @time_offset = 0
       @session = nil
       @connection_initialized = false
+      @user_id = nil
+      @access_hash = nil
 
       # Client configuration defaults
       @api_id = api_id || 0
@@ -45,29 +52,15 @@ module MTProto
       @connection.connect!
     end
 
-    def disconnect!
-      @connection.close if @connection
+    def connected?
+      @connection&.connected?
     end
 
-    def req_pq_multi
-      nonce = SecureRandom.random_bytes(16)
-
-      message = TL::Message.req_pq_multi(nonce)
-      payload = message.serialize
-
-      @connection.send(payload)
-
-      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
-
-      res_pq
+    def disconnect!
+      @connection.close if @connection
     end
 
-    def make_auth_key
+    def exchange_keys!
       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)
@@ -81,175 +74,71 @@ module MTProto
       result
     end
 
-    def generate_msg_id
-      time = Time.now.to_f + @time_offset
-      msg_id = (time * (2**32)).to_i
-      (msg_id / 4) * 4
+    def rpc
+      @rpc ||= RPC.new(self)
     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
+    def call(body, content_related: true)
+      rpc.call(body, content_related: content_related)
+    end
 
-        response_data = @connection.recv(timeout: @timeout)
-        decrypted = EncryptedMessage.decrypt(
-          auth_key: @auth_key,
-          encrypted_message_data: response_data,
-          sender: :server
+    def init_connection!
+      return if @connection_initialized
+
+      query = Type::RPC::InvokeWithLayer.build(
+        layer: 214,
+        query: Type::RPC::InitConnection.build(
+          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: Type::RPC::Help::GetConfig.build
         )
-        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
+      response = rpc.call_sync(query)
+      config = Type::RPC::Help::Config.parse(response)
 
-          return response_body
-        end
+      @connection_initialized = true
 
-        return container.messages.first[:body]
-      end
+      config
+    end
 
-      return response_body[12..] if constructor == 0xf35c6d01
+    def save_auth_data
+      raise 'Cannot save auth_data: auth_key not set' unless @auth_key
 
-      response_body
+      {
+        auth_key: Base64.strict_encode64(@auth_key),
+        server_salt: @server_salt,
+        user_id: @user_id,
+        access_hash: @access_hash,
+        dc_number: @dc_number,
+        time_offset: @time_offset
+      }
     end
 
-    def invoke_with_layer(layer, query)
-      body = TL::Serializer.serialize_int(0xda9b0d0d)
-      body += TL::Serializer.serialize_int(layer)
-      body += query
-      body
-    end
+    def load_auth_data(auth_data)
+      raise ArgumentError, 'auth_data must be a Hash' unless auth_data.is_a?(Hash)
+      raise ArgumentError, 'auth_key is required' unless auth_data[:auth_key]
+      raise ArgumentError, 'server_salt is required' unless auth_data[:server_salt]
 
-    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
+      @auth_key = Base64.strict_decode64(auth_data[:auth_key])
+      @server_salt = auth_data[:server_salt]
+      @time_offset = auth_data[:time_offset] || 0
+      @user_id = auth_data[:user_id]
+      @access_hash = auth_data[:access_hash]
 
-    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
+      @session = Session.new
 
-      rpc_call(query)
+      true
     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)
+    def update_user(user_id:, access_hash: nil)
+      @user_id = user_id
+      @access_hash = access_hash
     end
   end
 end

data/lib/mtproto/crypto/aes_ige.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 begin
-  require 'aes_ige/aes_ige'
+  require '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'

data/lib/mtproto/crypto/factorization.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 begin
-  require 'factorization/factorization'
+  require 'factorization'
 rescue LoadError => e
   warn "Failed to load Factorization C extension: #{e.message}"
   warn 'Run: cd ext/factorization && ruby extconf.rb && make'

data/lib/mtproto/message_id.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MTProto
+  module MessageId
+    module_function
+
+    def generate(time_offset: 0)
+      time = Time.now.to_f + time_offset
+      msg_id = (time * (2**32)).to_i
+      (msg_id / 4) * 4
+    end
+  end
+end

data/lib/mtproto/rpc/get_config.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/help/get_config'
+require_relative '../type/rpc/help/config'
+
+module MTProto
+  module RPC
+    class GetConfig
+      def initialize(client)
+        @client = client
+      end
+
+      def call
+        query = build_query
+
+        @client.rpc.call(query)
+      end
+
+      def call_sync
+        query = build_query
+
+        response = @client.rpc.call_sync(query)
+
+        Type::RPC::Help::Config.parse(response)
+      end
+
+      private
+
+      def build_query
+        Type::RPC::Help::GetConfig.build
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_contacts.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/contacts/get_contacts'
+require_relative '../type/rpc/contacts/contacts'
+
+module MTProto
+  module RPC
+    class GetContacts
+      def initialize(client)
+        @client = client
+      end
+
+      def call(hash: 0)
+        raise 'Auth key not generated' unless @client.auth_key
+
+        query = Type::RPC::Contacts::GetContacts.build(hash: hash)
+        @client.rpc.call(query)
+      end
+
+      def call_sync(hash: 0)
+        raise 'Auth key not generated' unless @client.auth_key
+
+        query = Type::RPC::Contacts::GetContacts.build(hash: hash)
+        response = @client.rpc.call_sync(query)
+        Type::RPC::Contacts::Contacts.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_updates_difference.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/updates/get_difference'
+require_relative '../type/rpc/updates/difference'
+
+module MTProto
+  module RPC
+    class GetUpdatesDifference
+      def initialize(client)
+        @client = client
+      end
+
+      def call(pts:, date:, qts:, pts_limit: 100, qts_limit: 100, pts_total_limit: nil)
+        raise 'Auth key not generated' unless @client.auth_key
+        raise ArgumentError, 'pts is required' if pts.nil?
+        raise ArgumentError, 'date is required' if date.nil?
+        raise ArgumentError, 'qts is required' if qts.nil?
+
+        query = Type::RPC::Updates::GetDifference.build(
+          pts: pts,
+          pts_limit: pts_limit,
+          pts_total_limit: pts_total_limit,
+          date: date,
+          qts: qts,
+          qts_limit: qts_limit
+        )
+
+        @client.rpc.call(query)
+      end
+
+      def call_sync(pts:, date:, qts:, pts_limit: 100, qts_limit: 100, pts_total_limit: nil)
+        raise 'Auth key not generated' unless @client.auth_key
+        raise ArgumentError, 'pts is required' if pts.nil?
+        raise ArgumentError, 'date is required' if date.nil?
+        raise ArgumentError, 'qts is required' if qts.nil?
+
+        query = Type::RPC::Updates::GetDifference.build(
+          pts: pts,
+          pts_limit: pts_limit,
+          pts_total_limit: pts_total_limit,
+          date: date,
+          qts: qts,
+          qts_limit: qts_limit
+        )
+
+        response = @client.rpc.call_sync(query)
+        Type::RPC::Updates::Difference.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_updates_state.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/updates/get_state'
+require_relative '../type/rpc/updates/state'
+
+module MTProto
+  module RPC
+    class GetUpdatesState
+      def initialize(client)
+        @client = client
+      end
+
+      def call
+        raise 'Auth key not generated' unless @client.auth_key
+
+        query = Type::RPC::Updates::GetState.build
+        @client.rpc.call(query)
+      end
+
+      def call_sync
+        raise 'Auth key not generated' unless @client.auth_key
+
+        query = Type::RPC::Updates::GetState.build
+        response = @client.rpc.call_sync(query)
+        Type::RPC::Updates::State.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_users.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/users/get_users'
+require_relative '../type/rpc/users/users'
+
+module MTProto
+  module RPC
+    class GetUsers
+      def initialize(client)
+        @client = client
+      end
+
+      def call
+        raise 'Auth key not generated' unless @client.auth_key
+
+        query = Type::RPC::Users::GetUsers.build
+        @client.rpc.call(query)
+      end
+
+      def call_sync
+        raise 'Auth key not generated' unless @client.auth_key
+
+        query = Type::RPC::Users::GetUsers.build
+        response = @client.rpc.call_sync(query)
+        Type::RPC::Users::Users.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/ping.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/ping'
+require_relative '../type/rpc/pong'
+
+module MTProto
+  module RPC
+    class Ping
+      def initialize(client)
+        @client = client
+      end
+
+      def call(ping_id = nil)
+        ping_id ||= rand(2**63)
+        body = Type::RPC::Ping.build(ping_id)
+
+        @client.rpc.call(body)
+      end
+
+      def call_sync(ping_id = nil)
+        ping_id ||= rand(2**63)
+        body = Type::RPC::Ping.build(ping_id)
+
+        response_body = @client.rpc.call_sync(body)
+        pong = Type::RPC::Pong.parse(response_body)
+
+        raise PingMismatchError unless pong[:ping_id] == ping_id
+
+        true
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/send_code.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/auth/send_code'
+require_relative '../type/rpc/auth/sent_code'
+
+module MTProto
+  module RPC
+    class SendCode
+      def initialize(client)
+        @client = client
+      end
+
+      def call(phone_number, code_settings: {})
+        query = build_query(phone_number, code_settings)
+
+        @client.rpc.call(query)
+      end
+
+      def call_sync(phone_number, code_settings: {})
+        query = build_query(phone_number, code_settings)
+
+        response = @client.rpc.call_sync(query)
+
+        Type::RPC::Auth::SentCode.parse(response)
+      end
+
+      private
+
+      def build_query(phone_number, code_settings)
+        raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+
+        Type::RPC::Auth::SendCode.build(
+          phone_number: phone_number,
+          api_id: @client.api_id,
+          api_hash: @client.api_hash,
+          code_settings: code_settings
+        )
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/send_message.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/messages/send_message'
+require_relative '../type/rpc/messages/updates'
+
+module MTProto
+  module RPC
+    class SendMessage
+      def initialize(client)
+        @client = client
+      end
+
+      def call(user_id:, access_hash:, message:, random_id: nil)
+        raise 'Auth key not generated' unless @client.auth_key
+        raise ArgumentError, 'user_id is required' if user_id.nil?
+        raise ArgumentError, 'access_hash is required' if access_hash.nil?
+        raise ArgumentError, 'message is required and cannot be empty' if message.nil? || message.empty?
+
+        query = Type::RPC::Messages::SendMessage.build(
+          user_id: user_id,
+          access_hash: access_hash,
+          message: message,
+          random_id: random_id
+        )
+
+        @client.rpc.call(query)
+      end
+
+      def call_sync(user_id:, access_hash:, message:, random_id: nil)
+        raise 'Auth key not generated' unless @client.auth_key
+        raise ArgumentError, 'user_id is required' if user_id.nil?
+        raise ArgumentError, 'access_hash is required' if access_hash.nil?
+        raise ArgumentError, 'message is required and cannot be empty' if message.nil? || message.empty?
+
+        query = Type::RPC::Messages::SendMessage.build(
+          user_id: user_id,
+          access_hash: access_hash,
+          message: message,
+          random_id: random_id
+        )
+
+        response = @client.rpc.call_sync(query)
+        Type::RPC::Messages::Updates.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/sign_in.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../type/rpc/auth/sign_in'
+require_relative '../type/rpc/auth/authorization'
+
+module MTProto
+  module RPC
+    class SignIn
+      def initialize(client)
+        @client = client
+      end
+
+      def call(phone_number:, phone_code_hash:, phone_code:)
+        query = build_query(phone_number, phone_code_hash, phone_code)
+
+        @client.rpc.call(query)
+      end
+
+      def call_sync(phone_number:, phone_code_hash:, phone_code:)
+        query = build_query(phone_number, phone_code_hash, phone_code)
+
+        response = @client.rpc.call_sync(query)
+
+        result = Type::RPC::Auth::Authorization.parse(response)
+
+        if result[:authorization] && result[:user_id]
+          @client.update_user(user_id: result[:user_id], access_hash: result[:access_hash])
+        end
+
+        result
+      end
+
+      private
+
+      def build_query(phone_number, phone_code_hash, phone_code)
+        raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+        raise ArgumentError, 'phone_code_hash is required' if phone_code_hash.nil? || phone_code_hash.empty?
+        raise ArgumentError, 'phone_code is required' if phone_code.nil? || phone_code.empty?
+
+        Type::RPC::Auth::SignIn.build(
+          phone_number: phone_number,
+          phone_code_hash: phone_code_hash,
+          phone_code: phone_code
+        )
+      end
+    end
+  end
+end