mtproto 0.0.8 → 0.0.10

data/lib/mtproto/tl/constructors.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    module Constructors
+      # Common
+      VECTOR = 0x1cb5c415
+      BOOL_TRUE = 0x997275b5
+      GZIP_PACKED = 0x3072cfa1
+      MSG_CONTAINER = 0x73f1f8dc
+      RPC_RESULT = 0xf35c6d01
+      RPC_ERROR = 0x2144ca19
+      BAD_SERVER_SALT = 0xedab447b
+      BAD_MSG_NOTIFICATION = 0xa7eff811
+      NEW_SESSION_CREATED = 0x9ec20908
+
+      # Peers
+      PEER_USER = 0x59511722
+      PEER_CHAT = 0x36c6019a
+      PEER_CHANNEL = 0xa2a5371e
+      INPUT_PEER_EMPTY = 0x7f3b18ea
+      INPUT_PEER_USER = 0xdde8a54c
+      INPUT_PEER_CHAT = 0x35a95cb9
+      INPUT_PEER_CHANNEL = 0x27bcbbfc
+      INPUT_USER_SELF = 0xf7c1b13f
+      INPUT_CHECK_PASSWORD_SRP = 0xd27ff082
+
+      # Auth key exchange
+      REQ_PQ_MULTI = 0xbe7e8ef1
+      RES_PQ = 0x05162463
+      PQ_INNER_DATA_DC = 0xa9f55f95
+      PQ_INNER_DATA_TEMP_DC = 0x56fddf88
+      REQ_DH_PARAMS = 0xd712e4be
+      SERVER_DH_PARAMS_OK = 0xd0e8075c
+      SERVER_DH_INNER_DATA = 0xb5890dba
+      CLIENT_DH_INNER_DATA = 0x6643b654
+      SET_CLIENT_DH_PARAMS = 0xf5045f1f
+      DH_GEN_OK = 0x3bcbf734
+      DH_GEN_RETRY = 0x46dc1fb9
+      DH_GEN_FAIL = 0xa69dae02
+
+      # Connection
+      INVOKE_WITH_LAYER = 0xda9b0d0d
+      INIT_CONNECTION = 0xc1cd5ea9
+      HELP_GET_CONFIG = 0xc4f9186b
+      CONFIG = 0xcc1a241e
+
+      # Auth
+      AUTH_SEND_CODE = 0xa677244f
+      AUTH_SENT_CODE = 0x5e002502
+      AUTH_SENT_CODE_TYPE_APP = 0x3dbb5986
+      AUTH_SENT_CODE_TYPE_SMS = 0xc000bba2
+      AUTH_SENT_CODE_TYPE_CALL = 0x5353e5a7
+      CODE_SETTINGS = 0xad253d78
+      AUTH_SIGN_IN = 0x8d52a951
+      AUTH_AUTHORIZATION = 0x2ea2c0d4
+      AUTH_AUTHORIZATION_SIGN_UP_REQUIRED = 0x44747e9a
+      AUTH_CHECK_PASSWORD = 0xd18b4d16
+      AUTH_EXPORT_LOGIN_TOKEN = 0xb7e085fe
+      AUTH_IMPORT_LOGIN_TOKEN = 0x95ac5ce4
+      AUTH_LOGIN_TOKEN = 0x629f1980
+      AUTH_LOGIN_TOKEN_MIGRATE_TO = 0x068e9916
+      AUTH_LOGIN_TOKEN_SUCCESS = 0x390d5c5e
+
+      # Account
+      ACCOUNT_GET_PASSWORD = 0x548a30f5
+      ACCOUNT_PASSWORD = 0x957b50fb
+      PASSWORD_KDF_ALGO_SHA256_MOD_POW = 0x3a912d4a
+
+      # Users
+      USERS_GET_USERS = 0x0d91a548
+      USER = 0x020b1422
+
+      # Messages
+      MESSAGES_GET_DIALOGS = 0xa0f4cb4f
+      MESSAGES_GET_HISTORY = 0x4423e6c5
+      MESSAGES_DIALOGS = 0x15ba6c40
+      MESSAGES_DIALOGS_SLICE = 0x71e094f3
+      MESSAGE = 0x9815cec8
+      DIALOG = 0xd58a08c6
+      CHAT = 0x41cbf256
+      CHAT_FORBIDDEN = 0x6592a1a7
+      CHANNEL = 0xfe685355
+      CHANNEL_FORBIDDEN = 0x17d493d5
+
+      # Updates
+      UPDATE_NEW_MESSAGE = 0x1f2b0afd
+      UPDATE_SHORT = 0x78d4dec1
+      UPDATE_SHORT_MESSAGE = 0x313bc7f8
+      UPDATES_GET_STATE = 0xedd4882a
+      UPDATES_STATE = 0xa56c2a3e
+      UPDATES_GET_DIFFERENCE = 0x19c2f763
+      UPDATES_DIFFERENCE_EMPTY = 0x5d75a138
+      UPDATES_DIFFERENCE = 0x00f49ca0
+      UPDATES_DIFFERENCE_SLICE = 0xa8fb1981
+      UPDATES_DIFFERENCE_TOO_LONG = 0x4afe8f6d
+    end
+  end
+end

data/lib/mtproto/tl/object.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Object
+      extend Binary
+
+      attr_reader :constructor, :payload
+
+      def initialize(constructor, payload)
+        @constructor = constructor
+        @payload = payload
+      end
+
+      def self.parse(message)
+        body = message.body
+        constructor_id = b_u32(body[0, 4])
+        constructor = ConstructorNames::NAMES.fetch(constructor_id)
+        payload = body[4..]
+
+        new(constructor, payload)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class AccountPassword
+      attr_reader :has_password, :current_algo, :srp_b, :srp_id
+
+      def initialize(has_password:, current_algo: nil, srp_b: nil, srp_id: nil)
+        @has_password = has_password
+        @current_algo = current_algo
+        @srp_b = srp_b
+        @srp_id = srp_id
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless constructor == Constructors::ACCOUNT_PASSWORD
+
+        offset = 4
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        has_password = flags.anybits?(1 << 2)
+
+        return new(has_password: false) unless has_password
+
+        algo_constructor = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        current_algo = nil
+        if algo_constructor == Constructors::PASSWORD_KDF_ALGO_SHA256_MOD_POW
+          salt1, offset = read_tl_bytes(data, offset)
+          salt2, offset = read_tl_bytes(data, offset)
+          g = data[offset, 4].unpack1('l<')
+          offset += 4
+          p, offset = read_tl_bytes(data, offset)
+
+          current_algo = { salt1: salt1, salt2: salt2, g: g, p: p }
+        end
+
+        srp_b, offset = read_tl_bytes(data, offset)
+        srp_id = data[offset, 8].unpack1('Q<')
+
+        new(has_password: true, current_algo: current_algo, srp_b: srp_b, srp_id: srp_id)
+      end
+
+      class << self
+        private
+
+        def read_tl_bytes(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte < 254
+            len = first_byte
+            bytes = data[offset + 1, len]
+            total = 1 + len
+          else
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            bytes = data[offset + 4, len]
+            total = 4 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [bytes, offset + total + padding]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Authorization
+      attr_reader :user_id, :access_hash, :flags, :sign_up_required
+
+      def initialize(user_id: nil, access_hash: nil, flags: 0, sign_up_required: false)
+        @user_id = user_id
+        @access_hash = access_hash
+        @flags = flags
+        @sign_up_required = sign_up_required
+      end
+
+      def authorization?
+        !@sign_up_required && @user_id
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+
+        return new(sign_up_required: true) if constructor == Constructors::AUTH_AUTHORIZATION_SIGN_UP_REQUIRED
+        raise UnexpectedConstructorError, constructor unless constructor == Constructors::AUTH_AUTHORIZATION
+
+        offset = 4
+
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        offset += 4 if flags.anybits?(1 << 0) # tmp_sessions
+        offset += 4 if flags.anybits?(1 << 1) # otherwise_relogin_days
+
+        offset = skip_tl_bytes(data, offset) if flags.anybits?(1 << 2) # future_auth_token
+
+        # user#20b1422 flags:# flags2:# id:long access_hash:flags.0?long ...
+        offset += 4 # user constructor
+
+        user_flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        offset += 4 # flags2
+
+        user_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+
+        access_hash = nil
+        access_hash = data[offset, 8].unpack1('Q<') if user_flags.anybits?(1 << 0)
+
+        new(user_id: user_id, access_hash: access_hash, flags: flags)
+      end
+
+      class << self
+        private
+
+        def skip_tl_bytes(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte < 254
+            total = 1 + first_byte
+          else
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            total = 4 + len
+          end
+          offset + total + ((4 - (total % 4)) % 4)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class CheckPassword
+      include Binary
+
+      attr_reader :srp_id, :a, :m1
+
+      def initialize(srp_id:, a:, m1:)
+        @srp_id = srp_id
+        @a = a
+        @m1 = m1
+      end
+
+      def body
+        u32_b(Constructors::AUTH_CHECK_PASSWORD) +
+          u32_b(Constructors::INPUT_CHECK_PASSWORD_SRP) +
+          u64_b(@srp_id) +
+          serialize_tl_bytes(@a) +
+          serialize_tl_bytes(@m1)
+      end
+
+      private
+
+      def serialize_tl_bytes(data)
+        bytes = data.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/client_dh_inner_data.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ClientDHInnerData
+      include Binary
+
+      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 body
+        result = u32_b(Constructors::CLIENT_DH_INNER_DATA)
+        result += @nonce.bytes
+        result += @server_nonce.bytes
+        result += u64_b(@retry_id)
+        result += serialize_tl_bytes(@g_b.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/dh_gen_response.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class DHGenResponse
+      extend Binary
+
+      attr_reader :status, :nonce, :server_nonce, :new_nonce_hash
+
+      def self.parse(message)
+        data = message.body
+        constructor = b_u32(data[0, 4])
+
+        status = case constructor
+                 when Constructors::DH_GEN_OK then :ok
+                 when Constructors::DH_GEN_RETRY then :retry
+                 when Constructors::DH_GEN_FAIL then :fail
+                 else 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
+        new_nonce_hash = data[offset, 16].pack('C*')
+
+        new(
+          status: status,
+          nonce: nonce,
+          server_nonce: server_nonce,
+          new_nonce_hash: new_nonce_hash
+        )
+      end
+
+      private
+
+      def initialize(status:, nonce:, server_nonce:, new_nonce_hash:)
+        @status = status
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @new_nonce_hash = new_nonce_hash
+      end
+    end
+  end
+end