mtproto 0.0.5 → 0.0.7

data/lib/mtproto/tl/message.rb

@@ -1,28 +1,13 @@
 # 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: '')
+      def initialize(auth_key_id:, msg_id:, body:)
         @auth_key_id = auth_key_id
-        @msg_id = msg_id || generate_msg_id
+        @msg_id = msg_id
         @body = body
       end
 
@@ -34,46 +19,13 @@ module MTProto
         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)
+        if data.bytesize < 20
+          raise(ArgumentError,
+            "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<')
         msg_id = data[8, 8].unpack1('Q<')
         body_length = data[16, 4].unpack1('L<')
@@ -81,166 +33,6 @@ module MTProto
 
         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/method_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'serializer'
+
+module MTProto
+  module TL
+    module MethodBuilder
+      def invoke_with_layer(layer, query)
+        body = Serializer.serialize_int(0xda9b0d0d)
+        body += Serializer.serialize_int(layer)
+        body + query
+      end
+
+      def init_connection(api_id:, device_model:, system_version:, app_version:, system_lang_code:, lang_pack:, lang_code:, query:)
+        body = Serializer.serialize_int(0xc1cd5ea9)
+        flags = 0
+        body += Serializer.serialize_int(flags)
+        body += Serializer.serialize_int(api_id)
+        body += Serializer.serialize_string(device_model)
+        body += Serializer.serialize_string(system_version)
+        body += Serializer.serialize_string(app_version)
+        body += Serializer.serialize_string(system_lang_code)
+        body += Serializer.serialize_string(lang_pack)
+        body += Serializer.serialize_string(lang_code)
+        body + query
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/auth/authorization.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+
+module MTProto
+  module TL
+    module RPC
+      module Auth
+        class Authorization
+          CONSTRUCTOR = 0x2ea2c0d4
+          CONSTRUCTOR_SIGN_UP_REQUIRED = 0x44747e9a
+
+          def self.parse(response)
+            constructor = response[0, 4].unpack1('L<')
+
+            if constructor == TL::GzipPacked::CONSTRUCTOR
+              response = TL::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+            end
+
+            if constructor == TL::RpcError::CONSTRUCTOR
+              error = TL::RpcError.deserialize(response)
+              raise MTProto::RpcError.new(error.error_code, error.error_message)
+            end
+
+            if constructor == CONSTRUCTOR_SIGN_UP_REQUIRED
+              return { authorization: nil, sign_up_required: true }
+            end
+
+            if constructor == CONSTRUCTOR
+              offset = 4
+
+              # Parse flags
+              flags = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              # tmp_sessions:flags.0?int
+              if (flags & (1 << 0)) != 0
+                offset += 4
+              end
+
+              # otherwise_relogin_days:flags.1?int
+              if (flags & (1 << 1)) != 0
+                offset += 4
+              end
+
+              # future_auth_token:flags.2?bytes
+              if (flags & (1 << 2)) != 0
+                first_byte = response[offset].unpack1('C')
+
+                if first_byte < 254
+                  # Short format: 1 byte length + data + padding
+                  token_len = first_byte
+                  offset += 1 + token_len
+                  padding = (4 - ((1 + token_len) % 4)) % 4
+                  offset += padding
+                else
+                  # Long format: 0xfe + 3 bytes length + data + padding
+                  offset += 1
+                  token_len = response[offset, 3].unpack('CCC').inject(0) {|sum, b| (sum << 8) + b}
+                  offset += 3 + token_len
+                  padding = (4 - ((4 + token_len) % 4)) % 4
+                  offset += padding
+                end
+              end
+
+              # Parse User object
+              # user#20b1422 flags:# flags2:# id:long access_hash:flags.0?long ...
+              user_constructor = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              user_flags = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              user_flags2 = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              # id:long (always present)
+              user_id = response[offset, 8].unpack1('Q<')
+              offset += 8
+
+              # access_hash:flags.0?long (conditional on flags.0)
+              access_hash = nil
+              if (user_flags & (1 << 0)) != 0
+                access_hash = response[offset, 8].unpack1('Q<')
+                offset += 8
+              end
+
+              # We have what we need, skip the rest of User fields
+
+              return {
+                authorization: true,
+                flags: flags,
+                sign_up_required: false,
+                user_id: user_id,
+                access_hash: access_hash
+              }
+            end
+
+            raise UnexpectedConstructorError.new(constructor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/auth/send_code.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../serializer'
+require_relative '../../code_settings'
+
+module MTProto
+  module TL
+    module RPC
+      module Auth
+        class SendCode
+          CONSTRUCTOR = 0xa677244f
+
+          def self.build(phone_number:, api_id:, api_hash:, code_settings: {})
+            raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+
+            query = [CONSTRUCTOR].pack('L<')
+            query += Serializer.serialize_string(phone_number)
+            query += Serializer.serialize_int(api_id)
+            query += Serializer.serialize_string(api_hash)
+            query += CodeSettings.serialize(code_settings)
+
+            query
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/auth/sent_code.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+require_relative '../../sent_code'
+
+module MTProto
+  module TL
+    module RPC
+      module Auth
+        class SentCode
+          def self.parse(response)
+            constructor = response[0, 4].unpack1('L<')
+
+            if constructor == TL::GzipPacked::CONSTRUCTOR
+              response = TL::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+            end
+
+            if constructor == TL::RpcError::CONSTRUCTOR
+              error = TL::RpcError.deserialize(response)
+              raise MTProto::RpcError.new(error.error_code, error.error_message)
+            end
+
+            if constructor == TL::SentCode::CONSTRUCTOR
+              sent_code = TL::SentCode.deserialize(response)
+              sent_code.to_h
+            else
+              raise UnexpectedConstructorError.new(constructor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/auth/sign_in.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../serializer'
+
+module MTProto
+  module TL
+    module RPC
+      module Auth
+        class SignIn
+          CONSTRUCTOR = 0x8d52a951
+
+          def self.build(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?
+
+            flags = 0
+            flags |= (1 << 0) # phone_code present
+
+            query = [CONSTRUCTOR].pack('L<')
+            query += Serializer.serialize_int(flags)
+            query += Serializer.serialize_string(phone_number)
+            query += Serializer.serialize_string(phone_code_hash)
+            query += Serializer.serialize_string(phone_code)
+
+            query
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/contacts/contacts.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+
+module MTProto
+  module TL
+    module RPC
+      module Contacts
+        class Contacts
+          CONSTRUCTOR_CONTACTS = 0xeae87e42
+          CONSTRUCTOR_CONTACTS_NOT_MODIFIED = 0xb74ba9d2
+          VECTOR_CONSTRUCTOR = 0x1cb5c415
+
+          def self.parse(response)
+            offset = 0
+
+            constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            if constructor == TL::GzipPacked::CONSTRUCTOR
+              response = TL::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+              offset = 4
+            end
+
+            if constructor == TL::RpcError::CONSTRUCTOR
+              error = TL::RpcError.deserialize(response)
+              raise MTProto::RpcError.new(error.error_code, error.error_message)
+            end
+
+            case constructor
+            when CONSTRUCTOR_CONTACTS_NOT_MODIFIED
+              # contacts.contactsNotModified#b74ba9d2 = contacts.Contacts;
+              {
+                contacts: [],
+                users: []
+              }
+
+            when CONSTRUCTOR_CONTACTS
+              # contacts.contacts#eae87e42 contacts:Vector<Contact> saved_count:int users:Vector<User> = contacts.Contacts;
+
+              # Parse contacts vector
+              contacts, offset = parse_contacts_vector(response, offset)
+
+              # Parse saved_count
+              saved_count = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              # Parse users vector
+              users, offset = parse_users_vector(response, offset)
+
+              {
+                contacts: contacts,
+                saved_count: saved_count,
+                users: users
+              }
+
+            else
+              raise "Unknown Contacts constructor: 0x#{constructor.to_s(16)}"
+            end
+          end
+
+          def self.parse_contacts_vector(response, offset)
+            vector_constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            return [[], offset] unless vector_constructor == VECTOR_CONSTRUCTOR
+
+            count = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            contacts = []
+            count.times do
+              contact, offset = parse_contact(response, offset)
+              contacts << contact if contact
+            end
+
+            [contacts, offset]
+          end
+
+          def self.parse_contact(response, offset)
+            # contact#145ade0b user_id:long mutual:Bool
+            constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            return [nil, offset] unless constructor == 0x145ade0b
+
+            user_id = response[offset, 8].unpack1('Q<')
+            offset += 8
+
+            mutual_constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+            mutual = mutual_constructor == 0x997275b5 # boolTrue
+
+            [{
+              user_id: user_id,
+              mutual: mutual
+            }, offset]
+          rescue StandardError
+            [nil, offset]
+          end
+
+          def self.parse_users_vector(response, offset)
+            vector_constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            return [[], offset] unless vector_constructor == VECTOR_CONSTRUCTOR
+
+            count = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            users = []
+            count.times do
+              user, offset = parse_user(response, offset)
+              users << user if user
+            end
+
+            [users, offset]
+          end
+
+          def self.parse_user(response, offset)
+            user_constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            # user#20b1422 flags:# flags2:# id:long access_hash:flags.0?long ...
+            return [nil, offset] unless user_constructor == 0x20b1422
+
+            flags = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            flags2 = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            user_id = response[offset, 8].unpack1('Q<')
+            offset += 8
+
+            access_hash = nil
+            if (flags & (1 << 0)) != 0
+              access_hash = response[offset, 8].unpack1('Q<')
+              offset += 8
+            end
+
+            [{
+              id: user_id,
+              access_hash: access_hash
+            }, offset]
+          rescue StandardError
+            [nil, offset]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/contacts/get_contacts.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    module RPC
+      module Contacts
+        class GetContacts
+          def self.build(hash: 0)
+            # contacts.getContacts#22c6aa08 hash:int = contacts.Contacts;
+            data = [0x22c6aa08].pack('L<')
+            data += [hash].pack('l<')
+            data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/help/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+require_relative '../../config'
+
+module MTProto
+  module TL
+    module RPC
+      module Help
+        class Config
+          def self.parse(response)
+            constructor = response[0, 4].unpack1('L<')
+
+            if constructor == TL::GzipPacked::CONSTRUCTOR
+              response = TL::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+            end
+
+            if constructor == TL::RpcError::CONSTRUCTOR
+              error = TL::RpcError.deserialize(response)
+              raise MTProto::RpcError.new(error.error_code, error.error_message)
+            end
+
+            if constructor == TL::Config::CONSTRUCTOR || constructor == TL::Config::CONSTRUCTOR_ALT
+              TL::Config.deserialize(response)
+            else
+              raise UnexpectedConstructorError.new(constructor)
+            end
+          end
+        end
+      end
+    end
+  end
+end