mtproto 0.0.6 → 0.0.8

data/lib/mtproto/type/auth_key/dh_gen_response.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Type
+    module AuthKey
+      class DHGenResponse
+        CONSTRUCTOR_DH_GEN_OK = 0x3bcbf734
+        CONSTRUCTOR_DH_GEN_RETRY = 0x46dc1fb9
+        CONSTRUCTOR_DH_GEN_FAIL = 0xa69dae02
+
+        def self.parse(body)
+          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
+      end
+    end
+  end
+end

data/lib/mtproto/type/auth_key/req_dh_params.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module Type
+    module AuthKey
+      class ReqDHParams
+        CONSTRUCTOR = 0xd712e4be
+
+        def self.build(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)
+          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)
+
+          body
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/type/auth_key/req_pq_multi.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Type
+    module AuthKey
+      class ReqPqMulti
+        CONSTRUCTOR = 0xbe7e8ef1
+
+        def self.build(nonce)
+          raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
+
+          constructor = [CONSTRUCTOR].pack('L<')
+          constructor + nonce
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/type/auth_key/res_pq.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Type
+    module AuthKey
+      class ResPq
+        CONSTRUCTOR = 0x05162463
+
+        def self.parse(body)
+          constructor = body[0, 4].unpack1('L<')
+          raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
+
+          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 self.padding_length(length)
+          (4 - (length % 4)) % 4
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/type/auth_key/server_dh_params.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Type
+    module AuthKey
+      class ServerDHParams
+        CONSTRUCTOR = 0xd0e8075c
+
+        def self.parse(body)
+          constructor = body[0, 4].unpack1('L<')
+          raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
+
+          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
+      end
+    end
+  end
+end

data/lib/mtproto/type/auth_key/set_client_dh_params.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module Type
+    module AuthKey
+      class SetClientDHParams
+        CONSTRUCTOR = 0xf5045f1f
+
+        def self.build(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)
+          body += nonce
+          body += server_nonce
+          body += Serializer.serialize_bytes(encrypted_data)
+
+          body
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/{tl → type}/bad_msg_notification.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MTProto
-  module TL
+  module Type
     class BadMsgNotification
       CONSTRUCTOR = 0xa7eff811
 

data/lib/mtproto/{tl → type}/client_dh_inner_data.rb

@@ -3,7 +3,7 @@
 require_relative 'serializer'
 
 module MTProto
-  module TL
+  module Type
     class ClientDHInnerData
       CONSTRUCTOR = 0x6643b654
 

data/lib/mtproto/{tl → type}/code_settings.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MTProto
-  module TL
+  module Type
     class CodeSettings
       CONSTRUCTOR = 0xad253d78
 

data/lib/mtproto/{tl → type}/config.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MTProto
-  module TL
+  module Type
     class Config
       CONSTRUCTOR = 0xcc1a241e
       CONSTRUCTOR_ALT = 0x3072cfa1

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

@@ -4,7 +4,7 @@ require 'zlib'
 require 'stringio'
 
 module MTProto
-  module TL
+  module Type
     module GzipPacked
       CONSTRUCTOR = 0x3072cfa1
 

data/lib/mtproto/type/message.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Type
+    class Message
+      attr_reader :auth_key_id, :msg_id, :body
+
+      def initialize(auth_key_id:, msg_id:, body:)
+        @auth_key_id = auth_key_id
+        @msg_id = 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.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<')
+        body = data[20, body_length]
+
+        new(auth_key_id: auth_key_id, msg_id: msg_id, body: body)
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MTProto
-  module TL
+  module Type
     class MsgContainer
       CONSTRUCTOR = 0x73f1f8dc
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MTProto
-  module TL
+  module Type
     class NewSessionCreated
       CONSTRUCTOR = 0x9ec20908
 

data/lib/mtproto/{tl/p_q_inner_data.rb → type/pq_inner_data.rb}

@@ -3,7 +3,7 @@
 require_relative 'serializer'
 
 module MTProto
-  module TL
+  module Type
     class PQInnerData
       CONSTRUCTOR_DC = 0xa9f55f95
       CONSTRUCTOR_TEMP_DC = 0x56fddf88

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+
+module MTProto
+  module Type
+    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 == Type::GzipPacked::CONSTRUCTOR
+              response = Type::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+            end
+
+            if constructor == Type::RpcError::CONSTRUCTOR
+              error = Type::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/type/rpc/auth/send_code.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../serializer'
+require_relative '../../code_settings'
+
+module MTProto
+  module Type
+    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/type/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 Type
+    module RPC
+      module Auth
+        class SentCode
+          def self.parse(response)
+            constructor = response[0, 4].unpack1('L<')
+
+            if constructor == Type::GzipPacked::CONSTRUCTOR
+              response = Type::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+            end
+
+            if constructor == Type::RpcError::CONSTRUCTOR
+              error = Type::RpcError.deserialize(response)
+              raise MTProto::RpcError.new(error.error_code, error.error_message)
+            end
+
+            if constructor == Type::SentCode::CONSTRUCTOR
+              sent_code = Type::SentCode.deserialize(response)
+              sent_code.to_h
+            else
+              raise UnexpectedConstructorError.new(constructor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../serializer'
+
+module MTProto
+  module Type
+    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