mtproto 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7f507f0d6cf42ac479bf224933efca12e7519cd67d7e9d8796ceba14f517960
-  data.tar.gz: 79c5137adfc60752fecb5367c6b90a08e7648f8fc523a95382fe7e755888c439
+  metadata.gz: 2744b720c59f90c3e9d18021ce6096a1c8e559dae949fbd6a9b53948c14f8b5c
+  data.tar.gz: 3b9000cabc247db305244b279bc58474466e1549cca3efa07ca1202eaa2d7874
 SHA512:
-  metadata.gz: 48de4193ba146630f831f690527cefcc0577c1bf56ab32452092e68dd75fa5bf86b294b8578e88e4daa26766c39ef78aa60c1a132e38975d6b01f0c21c508f29
-  data.tar.gz: 46d2ad65c9c1f59ea5f75789fb27008620117ab63877dad711add23cb6d477ad9cea5e5dffb724cc4d1d128a67dd9b75f8db9eddaf8e30a16005c377cb1a7542
+  metadata.gz: 874a17be8f75bb305057d0a0cb2c136441f9e8da883c44a99169ad0975c5b745b4323abc84ab6edb96b72f2c8f500ec40536a1a6724f585730501514a2e7475b
+  data.tar.gz: 6a693436a7443f789cb73a6fe6ecebf523ee288bb174b297fdfac4274340c9a5a00544299d08f0558028645e4cf80dbfb0c70c844ec47d2bb6e413589a45a5b2

data/lib/mtproto/auth_key_generator.rb

@@ -2,6 +2,13 @@
 
 require 'securerandom'
 require 'digest'
+require_relative 'message_id'
+require_relative 'tl/auth_key/req_pq_multi'
+require_relative 'tl/auth_key/res_pq'
+require_relative 'tl/auth_key/req_dh_params'
+require_relative 'tl/auth_key/server_dh_params'
+require_relative 'tl/auth_key/set_client_dh_params'
+require_relative 'tl/auth_key/dh_gen_response'
 
 module MTProto
   class AuthKeyGenerator
@@ -80,12 +87,13 @@ module MTProto
 
     def req_pq_multi
       nonce = SecureRandom.random_bytes(16)
-      message = TL::Message.req_pq_multi(nonce)
+      body = TL::AuthKey::ReqPqMulti.build(nonce)
+      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
       @connection.send(message.serialize)
 
       response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
-      res_pq = response_message.parse_res_pq
+      res_pq = TL::AuthKey::ResPq.parse(response_message.body)
 
       raise 'Nonce mismatch!' unless res_pq[:nonce] == nonce
 
@@ -120,7 +128,7 @@ module MTProto
     end
 
     def send_req_dh_params(res_pq, p, q, server_key, encrypted_data)
-      message = TL::Message.req_DH_params(
+      body = TL::AuthKey::ReqDHParams.build(
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         p: p,
@@ -128,12 +136,13 @@ module MTProto
         public_key_fingerprint: server_key.fingerprint,
         encrypted_data: encrypted_data
       )
+      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
 
       @connection.send(message.serialize)
 
       response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
-      server_dh_params = response_message.parse_server_DH_params_ok
+      server_dh_params = TL::AuthKey::ServerDHParams.parse(response_message.body)
 
       raise 'Nonce mismatch!' unless server_dh_params[:nonce] == res_pq[:nonce]
       raise 'Server nonce mismatch!' unless server_dh_params[:server_nonce] == res_pq[:server_nonce]
@@ -191,17 +200,18 @@ module MTProto
         tmp_aes_iv
       )
 
-      message = TL::Message.set_client_DH_params(
+      body = TL::AuthKey::SetClientDHParams.build(
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         encrypted_data: client_dh_encrypted
       )
+      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
 
       @connection.send(message.serialize)
 
       response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
-      response_message.parse_dh_gen_response
+      TL::AuthKey::DHGenResponse.parse(response_message.body)
     end
 
     def verify_dh_gen_response(dh_gen_response, res_pq, new_nonce, auth_key)

data/lib/mtproto/client/rpc.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../message_id'
+
+module MTProto
+  class Client
+    class RPC
+      CONSTRUCTOR_RPC_RESULT = 0xf35c6d01
+      CONSTRUCTOR_MSGS_ACK = 0x62d6b459
+      CONSTRUCTOR_BAD_SERVER_SALT = 0xedab447b
+
+      def initialize(client)
+        @client = client
+        @connection_initialized = false
+      end
+
+      def call(body, content_related: true)
+        raise 'Auth key not generated' unless @client.auth_key
+        raise 'Session not initialized' unless @client.session
+
+        msg_id = MessageId.generate(time_offset: @client.time_offset)
+        seq_no = @client.session.next_seq_no(content_related: content_related)
+
+        encrypted_msg = EncryptedMessage.encrypt(
+          auth_key: @client.auth_key,
+          server_salt: @client.server_salt,
+          session_id: @client.session.session_id,
+          msg_id: msg_id,
+          seq_no: seq_no,
+          body: body
+        )
+
+        @client.connection.send(encrypted_msg.serialize)
+
+        response_data = @client.connection.recv(timeout: @client.timeout)
+
+        decrypted = EncryptedMessage.decrypt(
+          auth_key: @client.auth_key,
+          encrypted_message_data: response_data,
+          sender: :server
+        )
+
+        response_body = decrypted[:body]
+
+        constructor = response_body[0, 4].unpack1('L<')
+
+        # Handle bad_server_salt
+        if constructor == CONSTRUCTOR_BAD_SERVER_SALT
+          # bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int error_code:int new_server_salt:long
+          offset = 4
+          bad_msg_id = response_body[offset, 8].unpack1('Q<')
+          offset += 8
+          bad_msg_seqno = response_body[offset, 4].unpack1('L<')
+          offset += 4
+          error_code = response_body[offset, 4].unpack1('L<')
+          offset += 4
+          new_server_salt = response_body[offset, 8].unpack1('Q<')
+
+          # Update server salt and retry
+          update_server_salt(new_server_salt)
+          return call(body, content_related: content_related)
+        end
+
+        if constructor == TL::NewSessionCreated::CONSTRUCTOR
+          session_info = TL::NewSessionCreated.deserialize(response_body)
+          update_server_salt(session_info.server_salt)
+
+          response_data = @client.connection.recv(timeout: @client.timeout)
+          decrypted = EncryptedMessage.decrypt(
+            auth_key: @client.auth_key,
+            encrypted_message_data: response_data,
+            sender: :server
+          )
+          response_body = decrypted[:body]
+          constructor = response_body[0, 4].unpack1('L<')
+        end
+
+        if constructor == TL::MsgContainer::CONSTRUCTOR
+          container = TL::MsgContainer.deserialize(response_body)
+
+          rpc_result = container.messages.find do |msg|
+            msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_RPC_RESULT
+          end
+
+          return rpc_result[:body][12..] if rpc_result
+
+          new_session = container.messages.find do |msg|
+            msg[:body][0, 4].unpack1('L<') == TL::NewSessionCreated::CONSTRUCTOR
+          end
+          if new_session
+            session_info = TL::NewSessionCreated.deserialize(new_session[:body])
+            update_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
+
+            return other_messages.first[:body] unless other_messages.empty?
+
+            response_data = @client.connection.recv(timeout: @client.timeout)
+            decrypted = EncryptedMessage.decrypt(
+              auth_key: @client.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 == CONSTRUCTOR_RPC_RESULT
+
+            if constructor == TL::MsgContainer::CONSTRUCTOR
+              container = TL::MsgContainer.deserialize(response_body)
+              rpc_result = container.messages.find do |msg|
+                msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_RPC_RESULT
+              end
+              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 == CONSTRUCTOR_RPC_RESULT
+
+        response_body
+      end
+
+      private
+
+      def update_server_salt(server_salt)
+        @client.instance_variable_set(:@server_salt, server_salt)
+      end
+    end
+  end
+end

data/lib/mtproto/client.rb

@@ -2,16 +2,19 @@
 
 require 'securerandom'
 require 'digest'
+require 'base64'
 require_relative 'transport/tcp_connection'
 require_relative 'transport/abridged_packet_codec'
 require_relative 'tl/message'
+require_relative 'client/rpc'
+require_relative 'tl/method_builder'
 
 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
+    include TL::MethodBuilder
 
-    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 +32,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
@@ -49,25 +54,7 @@ module MTProto
       @connection.close if @connection
     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
-    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 +68,43 @@ 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)
+    def save_session
+      raise 'Cannot save session: auth_key not set' unless @auth_key
 
-      encrypted_msg = EncryptedMessage.encrypt(
-        auth_key: @auth_key,
+      {
+        auth_key: Base64.strict_encode64(@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
+        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_session(session_data)
+      raise ArgumentError, 'session_data must be a Hash' unless session_data.is_a?(Hash)
+      raise ArgumentError, 'auth_key is required' unless session_data[:auth_key]
+      raise ArgumentError, 'server_salt is required' unless session_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(session_data[:auth_key])
+      @server_salt = session_data[:server_salt]
+      @time_offset = session_data[:time_offset] || 0
+      @user_id = session_data[:user_id]
+      @access_hash = session_data[:access_hash]
+
+      # Create a fresh session for the new connection
+      @session = Session.new
 
-    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)
+      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,37 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/help/get_config'
+require_relative '../tl/rpc/help/config'
+
+module MTProto
+  module RPC
+    class GetConfig
+      def initialize(client)
+        @client = client
+      end
+
+      def call
+        query = TL::RPC::Help::GetConfig.build
+
+        unless @client.instance_variable_get(:@connection_initialized)
+          query = @client.init_connection(
+            api_id: @client.api_id,
+            device_model: @client.device_model,
+            system_version: @client.system_version,
+            app_version: @client.app_version,
+            system_lang_code: @client.system_lang_code,
+            lang_pack: @client.lang_pack,
+            lang_code: @client.lang_code,
+            query: query
+          )
+          query = @client.invoke_with_layer(214, query)
+          @client.instance_variable_set(:@connection_initialized, true)
+        end
+
+        response = @client.rpc.call(query)
+
+        TL::RPC::Help::Config.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_contacts.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/contacts/get_contacts'
+require_relative '../tl/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 = TL::RPC::Contacts::GetContacts.build(hash: hash)
+        response = @client.rpc.call(query)
+        TL::RPC::Contacts::Contacts.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_updates_difference.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/updates/get_difference'
+require_relative '../tl/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 = TL::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(query)
+        TL::RPC::Updates::Difference.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_updates_state.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/updates/get_state'
+require_relative '../tl/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 = TL::RPC::Updates::GetState.build
+        response = @client.rpc.call(query)
+        TL::RPC::Updates::State.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_users.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/users/get_users'
+require_relative '../tl/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 = TL::RPC::Users::GetUsers.build
+        response = @client.rpc.call(query)
+        TL::RPC::Users::Users.parse(response)
+      end
+    end
+  end
+end