mtproto 0.0.8 → 0.0.10

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ResPq
+      extend Binary
+
+      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 == Constructors::RES_PQ
+
+        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 == Constructors::VECTOR
+
+        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/{type → tl/objects}/rpc_error.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 module MTProto
-  module Type
+  module TL
     class RpcError
-      CONSTRUCTOR = 0x2144ca19
-
       attr_reader :error_code, :error_message
 
       def self.deserialize(data)
@@ -16,7 +14,6 @@ module MTProto
         offset += 1
 
         error_message = data[offset, message_length]
-        offset += message_length
 
         new(error_code: error_code, error_message: error_message)
       end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SendCode
+      include Binary
+
+      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(Constructors::AUTH_SEND_CODE) +
+          serialize_tl_string(@phone_number) +
+          u32_b(@api_id) +
+          serialize_tl_string(@api_hash) +
+          code_settings
+      end
+
+      private
+
+      def code_settings
+        u32_b(Constructors::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
+      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 == Constructors::AUTH_SENT_CODE
+
+        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 Constructors::AUTH_SENT_CODE_TYPE_APP,
+               Constructors::AUTH_SENT_CODE_TYPE_SMS,
+               Constructors::AUTH_SENT_CODE_TYPE_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
+      attr_reader :nonce, :server_nonce, :g, :dh_prime, :g_a, :server_time
+
+      def self.parse(bytes)
+        constructor = bytes[0, 4].unpack1('L<')
+        unless constructor == Constructors::SERVER_DH_INNER_DATA
+          raise "Unexpected constructor: 0x#{constructor.to_s(16)}"
+        end
+
+        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
+
+      attr_reader :nonce, :server_nonce, :encrypted_answer
+
+      def self.parse(message)
+        data = message.body
+        constructor = b_u32(data[0, 4])
+        unless constructor == Constructors::SERVER_DH_PARAMS_OK
+          raise "Unexpected constructor: 0x#{constructor.to_s(16)}"
+        end
+
+        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,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SetClientDHParams
+      include Binary
+
+      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(Constructors::SET_CLIENT_DH_PARAMS)
+        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,45 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SignIn
+      include Binary
+
+      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(Constructors::AUTH_SIGN_IN) +
+          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

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Update
+      attr_reader :type, :text
+
+      def initialize(type, text: nil)
+        @type = type
+        @text = text
+      end
+
+      def self.parse(bytes)
+        constructor_id = bytes[0, 4].unpack1('L<')
+        type = type_name(constructor_id)
+
+        case constructor_id
+        when Constructors::UPDATE_NEW_MESSAGE
+          text = extract_new_message_text(bytes)
+          new(type, text: text)
+        else
+          new(type)
+        end
+      end
+
+      class << self
+        private
+
+        def type_name(constructor_id)
+          name = ConstructorNames::NAMES.fetch(constructor_id)
+          name.sub(/^update/, '')
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+        end
+
+        def extract_new_message_text(bytes)
+          offset = 4 # skip updateNewMessage constructor
+
+          msg_constructor = bytes[offset, 4].unpack1('L<')
+          return nil unless msg_constructor == Constructors::MESSAGE
+
+          offset += 4
+          flags = bytes[offset, 4].unpack1('L<')
+          offset += 4
+          flags2 = bytes[offset, 4].unpack1('L<')
+          offset += 4
+          offset += 4 # id
+
+          offset += 12 if flags & (1 << 8) != 0 # from_id: Peer
+          offset += 12 # peer_id: Peer
+          offset += 12 if flags & (1 << 28) != 0 # saved_peer_id: Peer
+          return nil if flags & (1 << 2) != 0 # fwd_from: variable length
+
+          offset += 8 if flags & (1 << 11) != 0 # via_bot_id: long
+          offset += 8 if flags2 & 1 != 0           # via_business_bot_id: long
+          return nil if flags & (1 << 3) != 0      # reply_to: variable length
+
+          offset += 4 # date
+          read_tl_string(bytes, offset)
+        end
+
+        def read_tl_string(bytes, offset)
+          first_byte = bytes.getbyte(offset)
+          if first_byte == 254
+            len = bytes.getbyte(offset + 1) |
+                  (bytes.getbyte(offset + 2) << 8) |
+                  (bytes.getbyte(offset + 3) << 16)
+            bytes[offset + 4, len]
+          else
+            bytes[offset + 1, first_byte]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UpdateShort
+      attr_reader :update, :date
+
+      def initialize(update, date)
+        @update = update
+        @date = date
+      end
+
+      def self.parse(bytes)
+        date = bytes[-4, 4].unpack1('l<')
+        update = Update.parse(bytes[4...-4])
+        new(update, date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UpdateShortMessage
+      attr_reader :flags, :id, :user_id, :text, :pts, :pts_count, :date
+
+      def initialize(flags:, id:, user_id:, text:, pts:, pts_count:, date:)
+        @flags = flags
+        @id = id
+        @user_id = user_id
+        @text = text
+        @pts = pts
+        @pts_count = pts_count
+        @date = date
+      end
+
+      def out?
+        flags & (1 << 1) != 0
+      end
+
+      def mentioned?
+        flags & (1 << 4) != 0
+      end
+
+      def self.parse(bytes)
+        offset = 4 # skip constructor
+        flags = bytes[offset, 4].unpack1('L<')
+        offset += 4
+        id = bytes[offset, 4].unpack1('l<')
+        offset += 4
+        user_id = bytes[offset, 8].unpack1('q<')
+        offset += 8
+        text, offset = read_tl_string(bytes, offset)
+        pts = bytes[offset, 4].unpack1('l<')
+        offset += 4
+        pts_count = bytes[offset, 4].unpack1('l<')
+        offset += 4
+        date = bytes[offset, 4].unpack1('l<')
+
+        new(flags: flags, id: id, user_id: user_id, text: text,
+          pts: pts, pts_count: pts_count, date: date)
+      end
+
+      class << self
+        private
+
+        def read_tl_string(bytes, offset)
+          first_byte = bytes.getbyte(offset)
+          if first_byte == 254
+            len = bytes.getbyte(offset + 1) |
+                  (bytes.getbyte(offset + 2) << 8) |
+                  (bytes.getbyte(offset + 3) << 16)
+            total = 4 + len
+          else
+            len = first_byte
+            total = 1 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [bytes[offset + (total - len), len], offset + total + padding]
+        end
+      end
+    end
+  end
+end