mtproto 0.0.3 → 0.0.5

data/lib/mtproto/session.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module MTProto
+  class Session
+    attr_reader :session_id, :seq_no
+
+    def initialize
+      @session_id = SecureRandom.random_bytes(8).unpack1('Q<')
+      @seq_no = 0
+    end
+
+    def next_seq_no(content_related: true)
+      current = @seq_no
+      @seq_no += content_related ? 1 : 0
+      current * 2 + (content_related ? 1 : 0)
+    end
+  end
+end

data/lib/mtproto/tl/bad_msg_notification.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class BadMsgNotification
+      CONSTRUCTOR = 0xa7eff811
+
+      attr_reader :bad_msg_id, :bad_msg_seqno, :error_code
+
+      def self.deserialize(data)
+        offset = 4
+        bad_msg_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+
+        bad_msg_seqno = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        error_code = data[offset, 4].unpack1('L<')
+
+        new(bad_msg_id: bad_msg_id, bad_msg_seqno: bad_msg_seqno, error_code: error_code)
+      end
+
+      def initialize(bad_msg_id:, bad_msg_seqno:, error_code:)
+        @bad_msg_id = bad_msg_id
+        @bad_msg_seqno = bad_msg_seqno
+        @error_code = error_code
+      end
+
+      def error_message
+        case @error_code
+        when 16 then "msg_id too low (client time is wrong)"
+        when 17 then "msg_id too high (client time needs sync)"
+        when 18 then "incorrect two lower order msg_id bits (must be divisible by 4)"
+        when 19 then "container msg_id is the same as previously received"
+        when 20 then "message too old"
+        when 32 then "msg_seqno too low"
+        when 33 then "msg_seqno too high"
+        when 34 then "even msg_seqno expected but odd received"
+        when 35 then "odd msg_seqno expected but even received"
+        when 48 then "incorrect server salt"
+        else "unknown error code #{@error_code}"
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/client_dh_inner_data.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'serializer'
+
+module MTProto
+  module TL
+    class ClientDHInnerData
+      CONSTRUCTOR = 0x6643b654
+
+      attr_reader :nonce, :server_nonce, :retry_id, :g_b
+
+      def initialize(nonce:, server_nonce:, retry_id:, g_b:)
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @retry_id = retry_id
+        @g_b = g_b
+      end
+
+      def serialize
+        data = Serializer.serialize_int(CONSTRUCTOR)
+        data += @nonce
+        data += @server_nonce
+        data += Serializer.serialize_long(@retry_id)
+        data += Serializer.serialize_bytes(@g_b)
+        data
+      end
+    end
+  end
+end

data/lib/mtproto/tl/config.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Config
+      CONSTRUCTOR = 0xcc1a241e
+      CONSTRUCTOR_ALT = 0x3072cfa1
+
+      attr_reader :flags, :date, :expires, :test_mode, :this_dc, :dc_options
+
+      def self.deserialize(data)
+        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<') == 0x997275b5)
+        offset += 4
+
+        this_dc = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        dc_options_constructor = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        raise "Expected vector constructor" unless dc_options_constructor == 0x1cb5c415
+
+        dc_options_count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        dc_options = []
+        dc_options_count.times do
+          dc_option, bytes_read = DcOption.deserialize_from(data[offset..])
+          dc_options << dc_option
+          offset += bytes_read
+        end
+
+        new(
+          flags: flags,
+          date: date,
+          expires: expires,
+          test_mode: test_mode,
+          this_dc: this_dc,
+          dc_options: dc_options
+        )
+      end
+
+      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
+    end
+
+    class DcOption
+      attr_reader :id, :ip_address, :port, :flags
+
+      def self.deserialize_from(data)
+        offset = 0
+        constructor = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        raise "Expected dcOption constructor" unless constructor == 0x18b7a10d
+
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        id = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        ip_length = data[offset].ord
+        offset += 1
+
+        ip_address = data[offset, ip_length]
+        offset += ip_length
+
+        padding = (4 - ((ip_length + 1) % 4)) % 4
+        offset += padding
+
+        port = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        [new(id: id, ip_address: ip_address, port: port, flags: flags), offset]
+      end
+
+      def initialize(id:, ip_address:, port:, flags:)
+        @id = id
+        @ip_address = ip_address
+        @port = port
+        @flags = flags
+      end
+
+      def ipv6?
+        (@flags & 1) != 0
+      end
+
+      def media_only?
+        (@flags & 2) != 0
+      end
+
+      def tcpo_only?
+        (@flags & 4) != 0
+      end
+
+      def cdn?
+        (@flags & 8) != 0
+      end
+
+      def static?
+        (@flags & 16) != 0
+      end
+    end
+  end
+end

data/lib/mtproto/tl/gzip_packed.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'zlib'
+require 'stringio'
+
+module MTProto
+  module TL
+    module GzipPacked
+      CONSTRUCTOR = 0x3072cfa1
+
+      module_function
+
+      def unpack(data)
+        offset = 4
+
+        length_byte = data[offset].ord
+        offset += 1
+        puts "    [GZIP] Length byte: #{length_byte} (0x#{length_byte.to_s(16)})" if $DEBUG
+
+        if length_byte == 254
+          length_bytes = data[offset, 3]
+          length = (length_bytes + "\x00").unpack1('L<')
+          offset += 3
+          puts "    [GZIP] Extended length: #{length} bytes" if $DEBUG
+        elsif length_byte == 255
+          raise "Invalid TL string length: 255"
+        else
+          length = length_byte
+          puts "    [GZIP] Short length: #{length} bytes" if $DEBUG
+        end
+
+        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
+
+        Zlib::GzipReader.new(StringIO.new(compressed_data)).read
+      end
+    end
+  end
+end

data/lib/mtproto/tl/message.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative 'serializer'
+
+module MTProto
+  module TL
+    class Message
+      CONSTRUCTOR_REQ_PQ_MULTI = 0xbe7e8ef1
+      CONSTRUCTOR_RES_PQ = 0x05162463
+      CONSTRUCTOR_REQ_DH_PARAMS = 0xd712e4be
+      CONSTRUCTOR_SERVER_DH_PARAMS_OK = 0xd0e8075c
+      CONSTRUCTOR_SET_CLIENT_DH_PARAMS = 0xf5045f1f
+      CONSTRUCTOR_DH_GEN_OK = 0x3bcbf734
+      CONSTRUCTOR_DH_GEN_RETRY = 0x46dc1fb9
+      CONSTRUCTOR_DH_GEN_FAIL = 0xa69dae02
+      CONSTRUCTOR_PING = 0x7abe77ec
+      CONSTRUCTOR_PONG = 0x347773c5
+      CONSTRUCTOR_BAD_MSG_NOTIFICATION = 0xa7eff811
+      CONSTRUCTOR_MSG_CONTAINER = 0x73f1f8dc
+
+      attr_reader :auth_key_id, :msg_id, :body
+
+      def initialize(auth_key_id: 0, msg_id: nil, body: '')
+        @auth_key_id = auth_key_id
+        @msg_id = msg_id || generate_msg_id
+        @body = body
+      end
+
+      def serialize
+        auth_key_id_bytes = [@auth_key_id].pack('Q<')
+        msg_id_bytes = [@msg_id].pack('Q<')
+        body_length = [@body.bytesize].pack('L<')
+
+        auth_key_id_bytes + msg_id_bytes + body_length + @body
+      end
+
+      def self.req_pq_multi(nonce)
+        raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
+
+        constructor = [CONSTRUCTOR_REQ_PQ_MULTI].pack('L<')
+        body = constructor + nonce
+
+        new(auth_key_id: 0, body: body)
+      end
+
+      def self.req_DH_params(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
+
+        p_bytes = Serializer.integer_to_bytes(p)
+        q_bytes = Serializer.integer_to_bytes(q)
+
+        body = Serializer.serialize_int(CONSTRUCTOR_REQ_DH_PARAMS)
+        body += nonce
+        body += server_nonce
+        body += Serializer.serialize_bytes(p_bytes)
+        body += Serializer.serialize_bytes(q_bytes)
+        body += Serializer.serialize_long(public_key_fingerprint)
+        body += Serializer.serialize_bytes(encrypted_data)
+
+        new(auth_key_id: 0, body: body)
+      end
+
+      def self.set_client_DH_params(nonce:, server_nonce:, 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
+
+        body = Serializer.serialize_int(CONSTRUCTOR_SET_CLIENT_DH_PARAMS)
+        body += nonce
+        body += server_nonce
+        body += Serializer.serialize_bytes(encrypted_data)
+
+        new(auth_key_id: 0, body: body)
+      end
+
+      def self.deserialize(data)
+        auth_key_id = data[0, 8].unpack1('Q<')
+        msg_id = data[8, 8].unpack1('Q<')
+        body_length = data[16, 4].unpack1('L<')
+        body = data[20, body_length]
+
+        new(auth_key_id: auth_key_id, msg_id: msg_id, body: body)
+      end
+
+      def parse_res_pq
+        constructor = @body[0, 4].unpack1('L<')
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR_RES_PQ
+
+        offset = 4
+
+        nonce = @body[offset, 16]
+        offset += 16
+
+        server_nonce = @body[offset, 16]
+        offset += 16
+
+        pq_length_byte = @body[offset].unpack1('C')
+        offset += 1
+
+        pq_length = if pq_length_byte == 254
+          @body[offset, 3].unpack1('L<') & 0xffffff
+          offset += 3
+        else
+          pq_length_byte
+        end
+
+        pq = @body[offset, pq_length]
+        offset += pq_length
+        offset += padding_length(pq_length + 1)
+
+        vector_constructor = @body[offset, 4].unpack1('L<')
+        offset += 4
+        raise 'Expected vector constructor' unless vector_constructor == 0x1cb5c415
+
+        fingerprints_count = @body[offset, 4].unpack1('L<')
+        offset += 4
+
+        fingerprints = []
+        fingerprints_count.times do
+          fingerprints << @body[offset, 8].unpack1('Q<')
+          offset += 8
+        end
+
+        {
+          nonce: nonce,
+          server_nonce: server_nonce,
+          pq: pq,
+          fingerprints: fingerprints
+        }
+      end
+
+      def parse_server_DH_params_ok
+        constructor = @body[0, 4].unpack1('L<')
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR_SERVER_DH_PARAMS_OK
+
+        offset = 4
+
+        nonce = @body[offset, 16]
+        offset += 16
+
+        server_nonce = @body[offset, 16]
+        offset += 16
+
+        length_byte = @body[offset].ord
+        offset += 1
+
+        if length_byte == 254
+          length_bytes = @body[offset, 3].bytes
+          encrypted_answer_length = length_bytes[0] | (length_bytes[1] << 8) | (length_bytes[2] << 16)
+          offset += 3
+        else
+          encrypted_answer_length = length_byte
+        end
+
+        encrypted_answer = @body[offset, encrypted_answer_length]
+
+        {
+          nonce: nonce,
+          server_nonce: server_nonce,
+          encrypted_answer: encrypted_answer
+        }
+      end
+
+      def parse_dh_gen_response
+        constructor = @body[0, 4].unpack1('L<')
+
+        offset = 4
+        nonce = @body[offset, 16]
+        offset += 16
+
+        server_nonce = @body[offset, 16]
+        offset += 16
+
+        new_nonce_hash = @body[offset, 16]
+
+        case constructor
+        when CONSTRUCTOR_DH_GEN_OK
+          { status: :ok, nonce: nonce, server_nonce: server_nonce, new_nonce_hash: new_nonce_hash }
+        when CONSTRUCTOR_DH_GEN_RETRY
+          { status: :retry, nonce: nonce, server_nonce: server_nonce, new_nonce_hash: new_nonce_hash }
+        when CONSTRUCTOR_DH_GEN_FAIL
+          { status: :fail, nonce: nonce, server_nonce: server_nonce, new_nonce_hash: new_nonce_hash }
+        else
+          raise "Unexpected constructor: 0x#{constructor.to_s(16)}"
+        end
+      end
+
+      def self.ping(ping_id)
+        body = Serializer.serialize_int(CONSTRUCTOR_PING)
+        body += [ping_id].pack('Q<')
+
+        body
+      end
+
+      def parse_pong
+        constructor = @body[0, 4].unpack1('L<')
+
+        if constructor == CONSTRUCTOR_BAD_MSG_NOTIFICATION
+          bad_msg = TL::BadMsgNotification.deserialize(@body)
+          raise "Bad message notification: #{bad_msg.error_message} (code: #{bad_msg.error_code}, msg_id: #{bad_msg.bad_msg_id}, seqno: #{bad_msg.bad_msg_seqno})"
+        end
+
+        if constructor == CONSTRUCTOR_MSG_CONTAINER
+          container = TL::MsgContainer.deserialize(@body)
+          pong_message = container.messages.find do |msg|
+            msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_PONG
+          end
+
+          raise 'No pong message found in container' unless pong_message
+
+          offset = 4
+          msg_id = pong_message[:body][offset, 8].unpack1('Q<')
+          offset += 8
+          ping_id = pong_message[:body][offset, 8].unpack1('Q<')
+
+          return { msg_id: msg_id, ping_id: ping_id }
+        end
+
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR_PONG
+
+        offset = 4
+        msg_id = @body[offset, 8].unpack1('Q<')
+        offset += 8
+        ping_id = @body[offset, 8].unpack1('Q<')
+
+        { msg_id: msg_id, ping_id: ping_id }
+      end
+
+      private
+
+      def generate_msg_id
+        time = Time.now.to_f
+        msg_id = (time * (2**32)).to_i
+        (msg_id / 4) * 4
+      end
+
+      def padding_length(length)
+        (4 - (length % 4)) % 4
+      end
+
+      def self.padding_length(length)
+        (4 - (length % 4)) % 4
+      end
+    end
+  end
+end

data/lib/mtproto/tl/msg_container.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class MsgContainer
+      CONSTRUCTOR = 0x73f1f8dc
+
+      attr_reader :messages
+
+      def self.deserialize(data)
+        offset = 4
+        message_count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        messages = []
+        message_count.times do
+          msg_id = data[offset, 8].unpack1('Q<')
+          offset += 8
+
+          seqno = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          bytes = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          body = data[offset, bytes]
+          offset += bytes
+
+          messages << { msg_id: msg_id, seqno: seqno, body: body }
+        end
+
+        new(messages: messages)
+      end
+
+      def initialize(messages:)
+        @messages = messages
+      end
+    end
+  end
+end

data/lib/mtproto/tl/new_session_created.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class NewSessionCreated
+      CONSTRUCTOR = 0x9ec20908
+
+      attr_reader :first_msg_id, :unique_id, :server_salt
+
+      def self.deserialize(data)
+        offset = 4
+        first_msg_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+
+        unique_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+
+        server_salt = data[offset, 8].unpack1('Q<')
+
+        new(first_msg_id: first_msg_id, unique_id: unique_id, server_salt: server_salt)
+      end
+
+      def initialize(first_msg_id:, unique_id:, server_salt:)
+        @first_msg_id = first_msg_id
+        @unique_id = unique_id
+        @server_salt = server_salt
+      end
+    end
+  end
+end

data/lib/mtproto/tl/p_q_inner_data.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'serializer'
+
+module MTProto
+  module TL
+    class PQInnerData
+      CONSTRUCTOR_DC = 0xa9f55f95
+      CONSTRUCTOR_TEMP_DC = 0x56fddf88
+
+      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 serialize
+        constructor = @expires_in ? CONSTRUCTOR_TEMP_DC : CONSTRUCTOR_DC
+
+        data = Serializer.serialize_int(constructor)
+        data += Serializer.serialize_bytes(Serializer.integer_to_bytes(@pq))
+        data += Serializer.serialize_bytes(Serializer.integer_to_bytes(@p))
+        data += Serializer.serialize_bytes(Serializer.integer_to_bytes(@q))
+        data += @nonce
+        data += @server_nonce
+        data += @new_nonce
+
+        data += Serializer.serialize_int(@expires_in) if @expires_in
+
+        data + Serializer.serialize_int(@dc)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc_error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class RpcError
+      CONSTRUCTOR = 0x2144ca19
+
+      attr_reader :error_code, :error_message
+
+      def self.deserialize(data)
+        offset = 4
+        error_code = data[offset, 4].unpack1('l<')
+        offset += 4
+
+        message_length = data[offset].ord
+        offset += 1
+
+        error_message = data[offset, message_length]
+        offset += message_length
+
+        new(error_code: error_code, error_message: error_message)
+      end
+
+      def initialize(error_code:, error_message:)
+        @error_code = error_code
+        @error_message = error_message
+      end
+
+      def to_s
+        "RPC Error #{@error_code}: #{@error_message}"
+      end
+    end
+  end
+end