mtproto 0.0.8 → 0.0.9

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'authorization'
+
+module MTProto
+  module TL
+    class LoginToken
+      CONSTRUCTOR_TOKEN = 0x629f1980
+      CONSTRUCTOR_MIGRATE_TO = 0x068e9916
+      CONSTRUCTOR_SUCCESS = 0x390d5c5e
+
+      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 CONSTRUCTOR_TOKEN
+          parse_token(data)
+        when CONSTRUCTOR_MIGRATE_TO
+          parse_migrate_to(data)
+        when CONSTRUCTOR_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/tl/objects/pq_inner_data.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class PQInnerData
+      include Binary
+
+      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 body
+        constructor = @expires_in ? CONSTRUCTOR_TEMP_DC : CONSTRUCTOR_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,65 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReqDHParams
+      include Binary
+
+      CONSTRUCTOR = 0xd712e4be
+
+      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(CONSTRUCTOR)
+        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,23 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReqPqMulti
+      include Binary
+
+      CONSTRUCTOR = 0xbe7e8ef1
+
+      attr_reader :nonce
+
+      def initialize(nonce)
+        raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
+
+        @nonce = nonce
+      end
+
+      def body
+        u32_b(CONSTRUCTOR) + @nonce.bytes
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ResPq
+      extend Binary
+
+      CONSTRUCTOR = 0x05162463
+
+      attr_reader :nonce, :server_nonce, :pq, :fingerprints
+
+      def self.parse(message)
+        data = message.body
+        constructor = b_u32(data[0, 4])
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
+
+        offset = 4
+
+        nonce = data[offset, 16].pack('C*')
+        offset += 16
+
+        server_nonce = data[offset, 16].pack('C*')
+        offset += 16
+
+        pq_length_byte = data[offset]
+        offset += 1
+
+        pq_length = if pq_length_byte == 254
+                      b_u32(data[offset, 3] + [0]) & 0xffffff
+                      offset += 3
+                    else
+                      pq_length_byte
+                    end
+
+        pq = data[offset, pq_length].pack('C*')
+        offset += pq_length
+        offset += padding_length(pq_length + 1)
+
+        vector_constructor = b_u32(data[offset, 4])
+        offset += 4
+        raise 'Expected vector constructor' unless vector_constructor == 0x1cb5c415
+
+        fingerprints_count = b_u32(data[offset, 4])
+        offset += 4
+
+        fingerprints = []
+        fingerprints_count.times do
+          fingerprints << b_u64(data[offset, 8])
+          offset += 8
+        end
+
+        new(
+          nonce: nonce,
+          server_nonce: server_nonce,
+          pq: pq,
+          fingerprints: fingerprints
+        )
+      end
+
+      def self.padding_length(length)
+        (4 - (length % 4)) % 4
+      end
+      private_class_method :padding_length
+
+      private
+
+      def initialize(nonce:, server_nonce:, pq:, fingerprints:)
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @pq = pq
+        @fingerprints = fingerprints
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SendCode
+      include Binary
+
+      CONSTRUCTOR = 0xa677244f
+      CODE_SETTINGS = 0xad253d78
+
+      attr_reader :phone_number, :api_id, :api_hash
+
+      def initialize(phone_number:, api_id:, api_hash:)
+        @phone_number = phone_number
+        @api_id = api_id
+        @api_hash = api_hash
+      end
+
+      def body
+        u32_b(CONSTRUCTOR) +
+          serialize_tl_string(@phone_number) +
+          u32_b(@api_id) +
+          serialize_tl_string(@api_hash) +
+          code_settings
+      end
+
+      private
+
+      def code_settings
+        u32_b(CODE_SETTINGS) + u32_b(0)
+      end
+
+      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/sent_code.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SentCode
+      CONSTRUCTOR = 0x5e002502
+
+      attr_reader :flags, :type, :phone_code_hash, :next_type, :timeout
+
+      def initialize(flags:, type:, phone_code_hash:, next_type: nil, timeout: nil)
+        @flags = flags
+        @type = type
+        @phone_code_hash = phone_code_hash
+        @next_type = next_type
+        @timeout = timeout
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless constructor == CONSTRUCTOR
+
+        offset = 4
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        type, offset = parse_sent_code_type(data, offset)
+
+        phone_code_hash, offset = read_tl_string(data, offset)
+
+        next_type = nil
+        next_type, offset = parse_code_type(data, offset) if flags.anybits?(1 << 1)
+
+        timeout = nil
+        timeout = data[offset, 4].unpack1('L<') if flags.anybits?(1 << 2)
+
+        new(flags: flags, type: type, phone_code_hash: phone_code_hash, next_type: next_type, timeout: timeout)
+      end
+
+      class << self
+        private
+
+        def parse_sent_code_type(data, offset)
+          constructor = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          case constructor
+          when 0x3dbb5986, 0xc000bba2, 0x5353e5a7 # app, sms, call
+            length = data[offset, 4].unpack1('L<')
+            offset += 4
+            [{ length: length }, offset]
+          else
+            [{}, offset]
+          end
+        end
+
+        def parse_code_type(data, offset)
+          constructor = data[offset, 4].unpack1('L<')
+          offset += 4
+          [constructor, offset]
+        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], offset + total + padding]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# 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.parse(bytes)
+        constructor = bytes[0, 4].unpack1('L<')
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
+
+        offset = 4
+
+        nonce = bytes[offset, 16]
+        offset += 16
+
+        server_nonce = bytes[offset, 16]
+        offset += 16
+
+        g = bytes[offset, 4].unpack1('L<')
+        offset += 4
+
+        dh_prime, offset = read_tl_bytes(bytes, offset)
+        g_a, offset = read_tl_bytes(bytes, offset)
+
+        server_time = bytes[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 self.read_tl_bytes(bytes, offset)
+        length_byte = bytes[offset].ord
+        offset += 1
+
+        if length_byte == 254
+          length_bytes = bytes[offset, 3].bytes
+          length = length_bytes[0] | (length_bytes[1] << 8) | (length_bytes[2] << 16)
+          offset += 3
+          header_size = 4
+        else
+          length = length_byte
+          header_size = 1
+        end
+
+        value = bytes[offset, length]
+        offset += length
+        offset += (4 - ((header_size + length) % 4)) % 4
+
+        [value, offset]
+      end
+      private_class_method :read_tl_bytes
+
+      private
+
+      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
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ServerDHParams
+      extend Binary
+
+      CONSTRUCTOR = 0xd0e8075c
+
+      attr_reader :nonce, :server_nonce, :encrypted_answer
+
+      def self.parse(message)
+        data = message.body
+        constructor = b_u32(data[0, 4])
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
+
+        offset = 4
+
+        nonce = data[offset, 16].pack('C*')
+        offset += 16
+
+        server_nonce = data[offset, 16].pack('C*')
+        offset += 16
+
+        length_byte = data[offset]
+        offset += 1
+
+        if length_byte == 254
+          encrypted_answer_length = data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16)
+          offset += 3
+        else
+          encrypted_answer_length = length_byte
+        end
+
+        encrypted_answer = data[offset, encrypted_answer_length].pack('C*')
+
+        new(
+          nonce: nonce,
+          server_nonce: server_nonce,
+          encrypted_answer: encrypted_answer
+        )
+      end
+
+      private
+
+      def initialize(nonce:, server_nonce:, encrypted_answer:)
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @encrypted_answer = encrypted_answer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SetClientDHParams
+      include Binary
+
+      CONSTRUCTOR = 0xf5045f1f
+
+      attr_reader :nonce, :server_nonce, :encrypted_data
+
+      def initialize(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
+
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @encrypted_data = encrypted_data
+      end
+
+      def body
+        result = u32_b(CONSTRUCTOR)
+        result += @nonce.bytes
+        result += @server_nonce.bytes
+        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
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SignIn
+      include Binary
+
+      CONSTRUCTOR = 0x8d52a951
+
+      attr_reader :phone_number, :phone_code_hash, :phone_code
+
+      def initialize(phone_number:, phone_code_hash:, phone_code:)
+        @phone_number = phone_number
+        @phone_code_hash = phone_code_hash
+        @phone_code = phone_code
+      end
+
+      def body
+        flags = 1 << 0
+
+        u32_b(CONSTRUCTOR) +
+          u32_b(flags) +
+          serialize_tl_string(@phone_number) +
+          serialize_tl_string(@phone_code_hash) +
+          serialize_tl_string(@phone_code)
+      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