mtproto 0.0.8 → 0.0.10

data/lib/mtproto/{type → tl/objects}/gzip_packed.rb

@@ -4,10 +4,8 @@ require 'zlib'
 require 'stringio'
 
 module MTProto
-  module Type
+  module TL
     module GzipPacked
-      CONSTRUCTOR = 0x3072cfa1
-
       module_function
 
       def unpack(data)
@@ -19,11 +17,11 @@ module MTProto
 
         if length_byte == 254
           length_bytes = data[offset, 3]
-          length = (length_bytes + "\x00").unpack1('L<')
+          length = "#{length_bytes}\u0000".unpack1('L<')
           offset += 3
           puts "    [GZIP] Extended length: #{length} bytes" if $DEBUG
         elsif length_byte == 255
-          raise "Invalid TL string length: 255"
+          raise 'Invalid TL string length: 255'
         else
           length = length_byte
           puts "    [GZIP] Short length: #{length} bytes" if $DEBUG
@@ -32,7 +30,9 @@ module MTProto
         raise "Invalid length: #{length.inspect}" unless length.is_a?(Integer) && length > 0
 
         compressed_data = data[offset, length]
-        raise "Not enough data: expected #{length}, got #{compressed_data&.bytesize}" if compressed_data.nil? || compressed_data.bytesize < length
+        if compressed_data.nil? || compressed_data.bytesize < length
+          raise "Not enough data: expected #{length}, got #{compressed_data&.bytesize}"
+        end
 
         Zlib::GzipReader.new(StringIO.new(compressed_data)).read.force_encoding(Encoding::BINARY)
       end

data/lib/mtproto/tl/objects/help_config.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class HelpConfig
+      attr_reader :flags, :date, :expires, :test_mode, :this_dc, :dc_options
+
+      def initialize(flags:, date:, expires:, test_mode:, this_dc:, dc_options:)
+        @flags = flags
+        @date = date
+        @expires = expires
+        @test_mode = test_mode
+        @this_dc = this_dc
+        @dc_options = dc_options
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        unless [Constructors::CONFIG, Constructors::GZIP_PACKED].include?(constructor)
+          raise UnexpectedConstructorError, constructor
+        end
+
+        offset = 4
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        date = data[offset, 4].unpack1('L<')
+        offset += 4
+        expires = data[offset, 4].unpack1('L<')
+        offset += 4
+        test_mode = data[offset, 4].unpack1('L<') == Constructors::BOOL_TRUE
+        offset += 4
+        this_dc = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        offset += 4 # vector constructor
+        dc_count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        dc_options = []
+        dc_count.times do
+          dc_option, offset = parse_dc_option(data, offset)
+          dc_options << dc_option
+        end
+
+        new(
+          flags: flags, date: date, expires: expires,
+          test_mode: test_mode, this_dc: this_dc, dc_options: dc_options
+        )
+      end
+
+      class << self
+        private
+
+        def parse_dc_option(data, offset)
+          offset += 4 # constructor
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          id = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          ip_len = data.getbyte(offset)
+          offset += 1
+          ip_address = data[offset, ip_len]
+          offset += ip_len
+          padding = (4 - ((ip_len + 1) % 4)) % 4
+          offset += padding
+
+          port = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          [{ id: id, ip_address: ip_address, port: port, flags: flags }, offset]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/import_login_token.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ImportLoginToken
+      include Binary
+
+      attr_reader :token
+
+      def initialize(token:)
+        @token = token
+      end
+
+      def body
+        u32_b(Constructors::AUTH_IMPORT_LOGIN_TOKEN) + serialize_tl_bytes(@token)
+      end
+
+      private
+
+      def serialize_tl_bytes(data)
+        bytes = data.bytes
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/init_connection.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class InitConnection
+      include Binary
+
+      attr_reader :api_id, :device_model, :system_version, :app_version,
+        :system_lang_code, :lang_pack, :lang_code, :query
+
+      def initialize(api_id:, device_model:, system_version:, app_version:,
+                     system_lang_code:, lang_pack:, lang_code:, query:)
+        @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
+      end
+
+      def body
+        flags = 0
+
+        result = u32_b(Constructors::INIT_CONNECTION)
+        result += u32_b(flags)
+        result += u32_b(@api_id)
+        result += serialize_tl_string(@device_model)
+        result += serialize_tl_string(@system_version)
+        result += serialize_tl_string(@app_version)
+        result += serialize_tl_string(@system_lang_code)
+        result += serialize_tl_string(@lang_pack)
+        result += serialize_tl_string(@lang_code)
+        result + @query.body
+      end
+
+      private
+
+      def serialize_tl_string(str)
+        bytes = str.encode('UTF-8').bytes
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/invoke_with_layer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class InvokeWithLayer
+      include Binary
+
+      attr_reader :layer, :query
+
+      def initialize(layer:, query:)
+        @layer = layer
+        @query = query
+      end
+
+      def body
+        u32_b(Constructors::INVOKE_WITH_LAYER) + u32_b(@layer) + @query.body
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/login_token.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'authorization'
+
+module MTProto
+  module TL
+    class LoginToken
+      attr_reader :type, :expires, :token, :dc_id, :authorization
+
+      def initialize(type:, expires: nil, token: nil, dc_id: nil, authorization: nil)
+        @type = type
+        @expires = expires
+        @token = token
+        @dc_id = dc_id
+        @authorization = authorization
+      end
+
+      def user_id
+        @authorization&.user_id
+      end
+
+      def access_hash
+        @authorization&.access_hash
+      end
+
+      def success?
+        @type == :success
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+
+        case constructor
+        when Constructors::AUTH_LOGIN_TOKEN
+          parse_token(data)
+        when Constructors::AUTH_LOGIN_TOKEN_MIGRATE_TO
+          parse_migrate_to(data)
+        when Constructors::AUTH_LOGIN_TOKEN_SUCCESS
+          new(type: :success, authorization: Authorization.parse(data[4..]))
+        else
+          raise UnexpectedConstructorError, constructor
+        end
+      end
+
+      class << self
+        private
+
+        def parse_token(data)
+          offset = 4
+          expires = data[offset, 4].unpack1('L<')
+          offset += 4
+          token = read_tl_bytes(data, offset)
+          new(type: :token, expires: expires, token: token)
+        end
+
+        def parse_migrate_to(data)
+          offset = 4
+          dc_id = data[offset, 4].unpack1('L<')
+          offset += 4
+          token = read_tl_bytes(data, offset)
+          new(type: :migrate_to, dc_id: dc_id, token: token)
+        end
+
+        def read_tl_bytes(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte < 254
+            data[offset + 1, first_byte]
+          else
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            data[offset + 4, len]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/{type → tl/objects}/message.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MTProto
-  module Type
+  module TL
     class Message
       attr_reader :auth_key_id, :msg_id, :body
 
@@ -22,8 +22,8 @@ module MTProto
       def self.deserialize(data)
         if data.bytesize < 20
           raise(ArgumentError,
-            "Invalid MTProto message: expected at least 20 bytes, got #{data.bytesize} bytes (hex: #{data.unpack1('H*')})",
-          )
+            'Invalid MTProto message: expected at least 20 bytes, ' \
+            "got #{data.bytesize} bytes (hex: #{data.unpack1('H*')})")
         end
 
         auth_key_id = data[0, 8].unpack1('Q<')

data/lib/mtproto/tl/objects/messages.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative '../schema'
+
+module MTProto
+  module TL
+    class Messages
+      Message = Struct.new(:id, :from_id, :date, :text, keyword_init: true)
+
+      MESSAGES_MESSAGES = 0x8c718e87
+      MESSAGES_SLICE = 0x762b263d
+      MESSAGES_CHANNEL = 0xc776ba4e
+
+      MESSAGE = Constructors::MESSAGE
+      MESSAGE_SERVICE = 0x7a800e0a
+      MESSAGE_EMPTY = 0x90a6ca84
+
+      VALID_CONSTRUCTORS = [MESSAGES_MESSAGES, MESSAGES_SLICE, MESSAGES_CHANNEL].freeze
+
+      attr_reader :messages, :count
+
+      def initialize(messages:, count: nil)
+        @messages = messages
+        @count = count
+      end
+
+      def slice?
+        !@count.nil?
+      end
+
+      def self.schema
+        @schema ||= Schema.new(
+          File.expand_path('../../../../data/tl-schema.json', __dir__)
+        )
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless VALID_CONSTRUCTORS.include?(constructor)
+
+        offset = 4
+        count = nil
+
+        case constructor
+        when MESSAGES_MESSAGES
+          # messages:Vector<Message> chats:Vector<Chat> users:Vector<User>
+        when MESSAGES_SLICE
+          # flags:# count:int next_rate:flags.0?int offset_id_offset:flags.2?int
+          # search_flood:flags.3?SearchPostsFlood messages:Vector<Message> ...
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+          offset += 4 if flags.anybits?(1 << 0) # next_rate
+          offset += 4 if flags.anybits?(1 << 2) # offset_id_offset
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # search_flood
+        when MESSAGES_CHANNEL
+          # flags:# pts:int count:int offset_id_offset:flags.2?int
+          # messages:Vector<Message> topics:Vector<ForumTopic> ...
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          offset += 4 # pts
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+          offset += 4 if flags.anybits?(1 << 2) # offset_id_offset
+        end
+
+        messages, offset = parse_messages_vector(data, offset)
+
+        # skip topics vector for channelMessages
+        schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) } if constructor == MESSAGES_CHANNEL
+
+        # skip chats and users (we don't need them here)
+
+        new(messages: messages, count: count)
+      end
+
+      class << self
+        private
+
+        def parse_messages_vector(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          messages = []
+          count.times do
+            constructor = data[offset, 4].unpack1('L<')
+
+            if constructor == MESSAGE
+              msg, = parse_message(data, offset)
+              messages << msg if msg
+            end
+
+            offset = schema.skip(data, offset)
+          end
+          [messages, offset]
+        end
+
+        # message#9815cec8 flags:# flags2:# id:int
+        #   from_id:flags.8?Peer ... date:int message:string ...
+        def parse_message(data, offset)
+          offset += 4 # constructor
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          flags2 = data[offset, 4].unpack1('L<')
+          offset += 4
+          id = data[offset, 4].unpack1('l<')
+          offset += 4
+
+          from_id = nil
+          _, from_id, offset = parse_peer(data, offset) if flags.anybits?(1 << 8)
+          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
+          _, _, offset = parse_peer(data, offset) # peer_id (skip)
+          _, _, offset = parse_peer(data, offset) if flags.anybits?(1 << 28) # saved_peer_id
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 2) # fwd_from
+          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
+          offset += 8 if flags2.anybits?(1 << 0) # via_business_bot_id
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # reply_to
+
+          date = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          text, offset = read_tl_string(data, offset)
+
+          msg = Message.new(id: id, from_id: from_id, date: date, text: text)
+          [msg, offset]
+        end
+
+        def parse_peer(data, offset)
+          constructor = data[offset, 4].unpack1('L<')
+          offset += 4
+          case constructor
+          when Constructors::PEER_USER
+            [:user, data[offset, 8].unpack1('Q<'), offset + 8]
+          when Constructors::PEER_CHAT
+            [:chat, data[offset, 8].unpack1('Q<'), offset + 8]
+          when Constructors::PEER_CHANNEL
+            [:channel, data[offset, 8].unpack1('Q<'), offset + 8]
+          else
+            raise "Unknown peer constructor: 0x#{constructor.to_s(16)}"
+          end
+        end
+
+        def read_tl_string(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte == 254
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            total = 4 + len
+          else
+            len = first_byte
+            total = 1 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [data[offset + (total - len), len].force_encoding('UTF-8'), offset + total + padding]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/{type → tl/objects}/msg_container.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 module MTProto
-  module Type
+  module TL
     class MsgContainer
-      CONSTRUCTOR = 0x73f1f8dc
-
       attr_reader :messages
 
       def self.deserialize(data)

data/lib/mtproto/{type → tl/objects}/new_session_created.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 module MTProto
-  module Type
+  module TL
     class NewSessionCreated
-      CONSTRUCTOR = 0x9ec20908
-
       attr_reader :first_msg_id, :unique_id, :server_salt
 
       def self.deserialize(data)

data/lib/mtproto/tl/objects/pq_inner_data.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class PQInnerData
+      include Binary
+
+      attr_reader :pq, :p, :q, :nonce, :server_nonce, :new_nonce, :dc, :expires_in
+
+      def initialize(pq:, p:, q:, nonce:, server_nonce:, new_nonce:, dc:, expires_in: nil)
+        @pq = pq
+        @p = p
+        @q = q
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @new_nonce = new_nonce
+        @dc = dc
+        @expires_in = expires_in
+      end
+
+      def body
+        constructor = @expires_in ? Constructors::PQ_INNER_DATA_TEMP_DC : Constructors::PQ_INNER_DATA_DC
+
+        result = u32_b(constructor)
+        result += serialize_tl_bytes(integer_to_bytes(@pq))
+        result += serialize_tl_bytes(integer_to_bytes(@p))
+        result += serialize_tl_bytes(integer_to_bytes(@q))
+        result += @nonce.bytes
+        result += @server_nonce.bytes
+        result += @new_nonce.bytes
+        result += u32_b(@expires_in) if @expires_in
+        result += u32_b(@dc)
+
+        result
+      end
+
+      private
+
+      def serialize_tl_bytes(bytes)
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+
+      def integer_to_bytes(int)
+        return [0] if int.zero?
+
+        bytes = []
+        while int > 0
+          bytes.unshift(int & 0xff)
+          int >>= 8
+        end
+        bytes
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/req_dh_params.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReqDHParams
+      include Binary
+
+      attr_reader :nonce, :server_nonce, :p, :q, :public_key_fingerprint, :encrypted_data
+
+      def initialize(nonce:, server_nonce:, p:, q:, public_key_fingerprint:, encrypted_data:)
+        raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
+        raise ArgumentError, 'Server nonce must be 16 bytes' unless server_nonce.bytesize == 16
+
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @p = p
+        @q = q
+        @public_key_fingerprint = public_key_fingerprint
+        @encrypted_data = encrypted_data
+      end
+
+      def body
+        result = u32_b(Constructors::REQ_DH_PARAMS)
+        result += @nonce.bytes
+        result += @server_nonce.bytes
+        result += serialize_tl_bytes(integer_to_bytes(@p))
+        result += serialize_tl_bytes(integer_to_bytes(@q))
+        result += u64_b(@public_key_fingerprint)
+        result += serialize_tl_bytes(@encrypted_data.bytes)
+
+        result
+      end
+
+      private
+
+      def serialize_tl_bytes(bytes)
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+
+      def integer_to_bytes(int)
+        return [0] if int.zero?
+
+        bytes = []
+        while int > 0
+          bytes.unshift(int & 0xff)
+          int >>= 8
+        end
+        bytes
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/req_pq_multi.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReqPqMulti
+      include Binary
+
+      attr_reader :nonce
+
+      def initialize(nonce)
+        raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
+
+        @nonce = nonce
+      end
+
+      def body
+        u32_b(Constructors::REQ_PQ_MULTI) + @nonce.bytes
+      end
+    end
+  end
+end