mtproto 0.0.4 → 0.0.5

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

@@ -1,10 +1,22 @@
 # 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
 
@@ -31,6 +43,36 @@ module MTProto
         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<')
@@ -87,11 +129,109 @@ module MTProto
         }
       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_ns = (Time.now.to_f * 1_000_000_000).to_i
-        (time_ns / 4) * 4
+        time = Time.now.to_f
+        msg_id = (time * (2**32)).to_i
+        (msg_id / 4) * 4
       end
 
       def padding_length(length)

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

data/lib/mtproto/tl/serializer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    module Serializer
+      module_function
+
+      def serialize_int(value)
+        [value].pack('L<')
+      end
+
+      def serialize_long(value)
+        [value].pack('Q<')
+      end
+
+      def serialize_int128(value)
+        value.is_a?(String) ? value : [value].pack('Q<Q<')
+      end
+
+      def serialize_int256(value)
+        value.is_a?(String) ? value : [value].pack('Q<Q<Q<Q<')
+      end
+
+      def serialize_bytes(bytes)
+        length = bytes.bytesize
+
+        if length <= 253
+          [length].pack('C').b + bytes.b + padding(length + 1)
+        else
+          [254].pack('C').b + [length].pack('L<')[0, 3].b + bytes.b + padding(length + 4)
+        end
+      end
+
+      def serialize_string(str)
+        serialize_bytes(str)
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        ("\x00" * pad_length).b
+      end
+
+      def integer_to_bytes(int)
+        return "\x00" if int.zero?
+
+        bytes = []
+        while int > 0
+          bytes.unshift(int & 0xff)
+          int >>= 8
+        end
+        bytes.pack('C*')
+      end
+    end
+  end
+end

data/lib/mtproto/tl/server_dh_inner_data.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ServerDHInnerData
+      CONSTRUCTOR = 0xb5890dba
+
+      attr_reader :nonce, :server_nonce, :g, :dh_prime, :g_a, :server_time
+
+      def self.deserialize(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
+
+        offset = 4
+
+        nonce = data[offset, 16]
+        offset += 16
+
+        server_nonce = data[offset, 16]
+        offset += 16
+
+        g = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        dh_prime_length_byte = data[offset].ord
+        offset += 1
+
+        if dh_prime_length_byte == 254
+          length_bytes = data[offset, 3].bytes
+          dh_prime_length = length_bytes[0] | (length_bytes[1] << 8) | (length_bytes[2] << 16)
+          offset += 3
+        else
+          dh_prime_length = dh_prime_length_byte
+        end
+
+        dh_prime = data[offset, dh_prime_length]
+        offset += dh_prime_length
+        offset += padding_length(dh_prime_length_byte == 254 ? dh_prime_length + 4 : dh_prime_length + 1)
+
+        g_a_length_byte = data[offset].ord
+        offset += 1
+
+        if g_a_length_byte == 254
+          length_bytes = data[offset, 3].bytes
+          g_a_length = length_bytes[0] | (length_bytes[1] << 8) | (length_bytes[2] << 16)
+          offset += 3
+        else
+          g_a_length = g_a_length_byte
+        end
+
+        g_a = data[offset, g_a_length]
+        offset += g_a_length
+        offset += padding_length(g_a_length_byte == 254 ? g_a_length + 4 : g_a_length + 1)
+
+        server_time = data[offset, 4].unpack1('L<')
+
+        new(
+          nonce: nonce,
+          server_nonce: server_nonce,
+          g: g,
+          dh_prime: dh_prime,
+          g_a: g_a,
+          server_time: server_time
+        )
+      end
+
+      def initialize(nonce:, server_nonce:, g:, dh_prime:, g_a:, server_time:)
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @g = g
+        @dh_prime = dh_prime
+        @g_a = g_a
+        @server_time = server_time
+      end
+
+      def self.padding_length(length)
+        (4 - (length % 4)) % 4
+      end
+
+      def padding_length(length)
+        self.class.padding_length(length)
+      end
+    end
+  end
+end

data/lib/mtproto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MTProto
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/mtproto.rb

@@ -4,7 +4,27 @@ require_relative 'mtproto/version'
 require_relative 'mtproto/transport/abridged_packet_codec'
 require_relative 'mtproto/transport/tcp_connection'
 require_relative 'mtproto/tl/message'
+require_relative 'mtproto/tl/serializer'
+require_relative 'mtproto/tl/p_q_inner_data'
+require_relative 'mtproto/tl/server_dh_inner_data'
+require_relative 'mtproto/tl/client_dh_inner_data'
+require_relative 'mtproto/tl/bad_msg_notification'
+require_relative 'mtproto/tl/msg_container'
+require_relative 'mtproto/tl/new_session_created'
+require_relative 'mtproto/tl/rpc_error'
+require_relative 'mtproto/tl/gzip_packed'
+require_relative 'mtproto/tl/config'
 require_relative 'mtproto/crypto/rsa_key'
+require_relative 'mtproto/crypto/factorization'
+require_relative 'mtproto/crypto/aes_ige'
+require_relative 'mtproto/crypto/rsa_pad'
+require_relative 'mtproto/crypto/auth_key_helper'
+require_relative 'mtproto/crypto/dh_validator'
+require_relative 'mtproto/crypto/dh_key_exchange'
+require_relative 'mtproto/crypto/message_key'
+require_relative 'mtproto/auth_key_generator'
+require_relative 'mtproto/session'
+require_relative 'mtproto/encrypted_message'
 require_relative 'mtproto/client'
 
 module MTProto