mtproto 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93bf74e47e4eb9cea99def85727f559cc3fcbe484411ba181b6ac596ed24fcbe
-  data.tar.gz: c0b1bc2e59a38eb2042d938692ba1959bbad1633a0594858ce9c1991444f4ef0
+  metadata.gz: 46c1ad0b399a4ecb8502c4783d7a032be25a502620357a0a04009d01ae3feb48
+  data.tar.gz: 28f124987f99bb50e8fa4cc6a9f00b77a926b7285ab159039987369ab1359a88
 SHA512:
-  metadata.gz: 9a5cd8f10a36c676db3ba4e642f9f7d1a209600278b3d571c86dfcf78f489613603919a8c1f950b8e3b71e2a1a721a4b0fab721b2e318eb30ff7960edfe6b4df
-  data.tar.gz: e98baafabd0e49ea34d1cc7d92b6761a1b899fec53c19faccd96ada01989b8784ac6114e597f28a1f0a15f34ed95cb600948f89decdee66c0d84c6ec1e716194
+  metadata.gz: 89d8dbe1f183814f2a6f9b485d85f0ae6b92c4895aae6c2493a41a54a740090af30910c0086de0e82d53415905e32a7a2a8b0273eff66393c594ae5ebe1bee1b
+  data.tar.gz: 31793f4d495ccceb6a18959261673e8d3c0388ff9bd02f8bf848ea093dcedde7457412763aeaa87f942251c49906dcd7b39bb9d03b3ade3f64d4b17a8df433f5

data/ext/aes_ige/extconf.rb

@@ -6,18 +6,12 @@ require 'mkmf'
 dir_config('openssl')
 
 # Check for OpenSSL headers and libraries
-unless have_header('openssl/aes.h')
-  abort 'OpenSSL headers not found. Please install OpenSSL development files.'
-end
+abort 'OpenSSL headers not found. Please install OpenSSL development files.' unless have_header('openssl/aes.h')
 
-unless have_library('ssl') && have_library('crypto')
-  abort 'OpenSSL libraries not found. Please install OpenSSL.'
-end
+abort 'OpenSSL libraries not found. Please install OpenSSL.' unless have_library('ssl') && have_library('crypto')
 
 # Check for AES_ige_encrypt function
-unless have_func('AES_ige_encrypt', 'openssl/aes.h')
-  abort 'AES_ige_encrypt function not found in OpenSSL library.'
-end
+abort 'AES_ige_encrypt function not found in OpenSSL library.' unless have_func('AES_ige_encrypt', 'openssl/aes.h')
 
 # Suppress deprecation warnings for OpenSSL 3.0
 $CFLAGS += ' -Wno-deprecated-declarations'

data/ext/factorization/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 
 create_makefile('factorization/factorization')

data/lib/mtproto/auth_key_generator.rb

@@ -2,21 +2,23 @@
 
 require 'securerandom'
 require 'digest'
-require_relative 'message_id'
-require_relative 'type/auth_key/req_pq_multi'
-require_relative 'type/auth_key/res_pq'
-require_relative 'type/auth_key/req_dh_params'
-require_relative 'type/auth_key/server_dh_params'
-require_relative 'type/auth_key/set_client_dh_params'
-require_relative 'type/auth_key/dh_gen_response'
+require_relative 'tl/objects/req_pq_multi'
+require_relative 'tl/objects/res_pq'
+require_relative 'tl/objects/pq_inner_data'
+require_relative 'tl/objects/req_dh_params'
+require_relative 'tl/objects/server_dh_params'
+require_relative 'tl/objects/server_dh_inner_data'
+require_relative 'tl/objects/client_dh_inner_data'
+require_relative 'tl/objects/set_client_dh_params'
+require_relative 'tl/objects/dh_gen_response'
 
 module MTProto
   class AuthKeyGenerator
     attr_reader :connection, :auth_key, :server_salt, :time_offset, :timeout
 
     def initialize(connection, public_key, dc_number = nil, test_mode: false, timeout: 10)
-      raise ArgumentError, "public_key is required" if public_key.nil? || public_key.empty?
-      raise ArgumentError, "dc_number must be positive. Use test_mode: true for test DCs" if dc_number && dc_number < 0
+      raise ArgumentError, 'public_key is required' if public_key.nil? || public_key.empty?
+      raise ArgumentError, 'dc_number must be positive. Use test_mode: true for test DCs' if dc_number && dc_number < 0
 
       @connection = connection
       @public_key = public_key
@@ -29,13 +31,15 @@ module MTProto
     end
 
     def generate
-      res_pq = req_pq_multi
-      server_key = find_server_key(res_pq[:fingerprints])
-      p, q = Crypto::Factorization.factorize_pq(res_pq[:pq])
+      res_pq = send_and_receive(TL::ReqPqMulti.new(SecureRandom.random_bytes(16)), TL::ResPq)
+
+      server_key = Crypto::RSAKey.find_by_fingerprint(res_pq.fingerprints, @public_key)
+      raise 'No matching RSA key found!' unless server_key
+
+      p, q = Crypto::Factorization.factorize_pq(res_pq.pq)
       new_nonce = SecureRandom.random_bytes(32)
 
-      encrypted_data = encrypt_pq_inner_data(res_pq, p, q, server_key, new_nonce)
-      server_dh_params = send_req_dh_params(res_pq, p, q, server_key, encrypted_data)
+      server_dh_params = send_req_dh_params(res_pq, p, q, server_key, new_nonce)
       server_dh_inner_data = decrypt_server_dh_params(res_pq, new_nonce, server_dh_params)
 
       Crypto::DHValidator.validate_dh_params(
@@ -55,8 +59,8 @@ module MTProto
         server_dh_inner_data.dh_prime
       )
 
-      tmp_aes_key = Crypto::AuthKeyHelper.derive_tmp_aes_key(new_nonce, res_pq[:server_nonce])
-      tmp_aes_iv = Crypto::AuthKeyHelper.derive_tmp_aes_iv(new_nonce, res_pq[:server_nonce])
+      tmp_aes_key = Crypto::AuthKeyHelper.derive_tmp_aes_key(new_nonce, res_pq.server_nonce)
+      tmp_aes_iv = Crypto::AuthKeyHelper.derive_tmp_aes_iv(new_nonce, res_pq.server_nonce)
 
       dh_gen_response = send_client_dh_params(
         res_pq,
@@ -66,96 +70,69 @@ module MTProto
         tmp_aes_iv
       )
 
-      verify_dh_gen_response(dh_gen_response, res_pq, new_nonce, auth_key)
+      verify_dh_gen_response(dh_gen_response, new_nonce, auth_key)
 
       @auth_key = auth_key
-      @server_salt = compute_server_salt(new_nonce, res_pq[:server_nonce])
+      @server_salt = compute_server_salt(new_nonce, res_pq.server_nonce)
       @time_offset = server_dh_inner_data.server_time - Time.now.to_i
 
       {
         auth_key: @auth_key,
         server_salt: @server_salt,
-        time_offset: @time_offset,
-        server_dh_params: server_dh_params,
-        server_dh_inner_data: server_dh_inner_data,
-        client_dh_params: client_dh_params,
-        dh_gen_response: dh_gen_response
+        time_offset: @time_offset
       }
     end
 
     private
 
-    def req_pq_multi
-      nonce = SecureRandom.random_bytes(16)
-      body = Type::AuthKey::ReqPqMulti.build(nonce)
-      message = Type::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
-      @connection.send(message.serialize)
+    def send_and_receive(rpc, response_class)
+      message = Message.new(rpc.body)
+      @connection.send(Transport::Packet.new(message.bytes))
 
-      response_data = @connection.recv(timeout: @timeout)
-      response_message = Type::Message.deserialize(response_data)
-      res_pq = Type::AuthKey::ResPq.parse(response_message.body)
+      response_packet = @connection.receive
+      raise 'Receive timeout' if response_packet.nil?
 
-      raise 'Nonce mismatch!' unless res_pq[:nonce] == nonce
-
-      res_pq
-    end
+      result = response_class.parse(Message.parse(response_packet))
 
-    def find_server_key(fingerprints)
-      server_key = Crypto::RSAKey.find_by_fingerprint(fingerprints, @public_key)
-      raise 'No matching RSA key found!' unless server_key
+      raise 'Nonce mismatch!' if rpc.respond_to?(:nonce) && result.nonce != rpc.nonce
+      raise 'Server nonce mismatch!' if rpc.respond_to?(:server_nonce) && result.server_nonce != rpc.server_nonce
 
-      server_key
+      result
     end
 
-    def encrypt_pq_inner_data(res_pq, p, q, server_key, new_nonce)
-      raise ArgumentError, "dc_number is required for auth key generation" if @dc_number.nil?
+    def send_req_dh_params(res_pq, p, q, server_key, new_nonce)
+      raise ArgumentError, 'dc_number is required for auth key generation' if @dc_number.nil?
 
-      # For test DCs, add 10000 to the DC number per MTProto spec
-      # For production DCs, use the DC number as-is
-      dc_value = @test_mode ? (@dc_number + 10000) : @dc_number
+      dc_value = @test_mode ? (@dc_number + 10_000) : @dc_number
 
-      inner_data = Type::PQInnerData.new(
-        pq: Crypto::Factorization.bytes_to_integer(res_pq[:pq]),
+      inner_data = TL::PQInnerData.new(
+        pq: Crypto::Factorization.bytes_to_integer(res_pq.pq),
         p: p,
         q: q,
-        nonce: res_pq[:nonce],
-        server_nonce: res_pq[:server_nonce],
+        nonce: res_pq.nonce,
+        server_nonce: res_pq.server_nonce,
         new_nonce: new_nonce,
         dc: dc_value
       )
+      encrypted_data = Crypto::RSA_PAD.encrypt(inner_data.body.pack('C*'), server_key)
 
-      Crypto::RSA_PAD.encrypt(inner_data.serialize, server_key)
-    end
-
-    def send_req_dh_params(res_pq, p, q, server_key, encrypted_data)
-      body = Type::AuthKey::ReqDHParams.build(
-        nonce: res_pq[:nonce],
-        server_nonce: res_pq[:server_nonce],
+      rpc = TL::ReqDHParams.new(
+        nonce: res_pq.nonce,
+        server_nonce: res_pq.server_nonce,
         p: p,
         q: q,
         public_key_fingerprint: server_key.fingerprint,
         encrypted_data: encrypted_data
       )
-      message = Type::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
-
-      @connection.send(message.serialize)
-
-      response_data = @connection.recv(timeout: @timeout)
-      response_message = Type::Message.deserialize(response_data)
-      server_dh_params = Type::AuthKey::ServerDHParams.parse(response_message.body)
-
-      raise 'Nonce mismatch!' unless server_dh_params[:nonce] == res_pq[:nonce]
-      raise 'Server nonce mismatch!' unless server_dh_params[:server_nonce] == res_pq[:server_nonce]
-
-      server_dh_params
+      send_and_receive(rpc, TL::ServerDHParams)
     end
 
     def decrypt_server_dh_params(res_pq, new_nonce, server_dh_params)
-      tmp_aes_key = Crypto::AuthKeyHelper.derive_tmp_aes_key(new_nonce, res_pq[:server_nonce])
-      tmp_aes_iv = Crypto::AuthKeyHelper.derive_tmp_aes_iv(new_nonce, res_pq[:server_nonce])
+      tmp_aes_key = Crypto::AuthKeyHelper.derive_tmp_aes_key(new_nonce, res_pq.server_nonce)
+      tmp_aes_iv = Crypto::AuthKeyHelper.derive_tmp_aes_iv(new_nonce, res_pq.server_nonce)
 
       answer_with_hash = Crypto::AES_IGE.decrypt_ige(
-        server_dh_params[:encrypted_answer],
+        server_dh_params.encrypted_answer,
         tmp_aes_key,
         tmp_aes_iv
       )
@@ -172,23 +149,18 @@ module MTProto
         answer = answer[0..-2]
       end
 
-      server_dh_inner_data = Type::ServerDHInnerData.deserialize(answer)
-
-      raise 'Nonce mismatch in DH inner data!' unless server_dh_inner_data.nonce == res_pq[:nonce]
-      raise 'Server nonce mismatch in DH inner data!' unless server_dh_inner_data.server_nonce == res_pq[:server_nonce]
-
-      server_dh_inner_data
+      TL::ServerDHInnerData.parse(answer)
     end
 
-    def send_client_dh_params(res_pq, new_nonce, client_dh_params, tmp_aes_key, tmp_aes_iv)
-      client_dh_inner_data = Type::ClientDHInnerData.new(
-        nonce: res_pq[:nonce],
-        server_nonce: res_pq[:server_nonce],
+    def send_client_dh_params(res_pq, _new_nonce, client_dh_params, tmp_aes_key, tmp_aes_iv)
+      client_dh_inner_data = TL::ClientDHInnerData.new(
+        nonce: res_pq.nonce,
+        server_nonce: res_pq.server_nonce,
         retry_id: 0,
         g_b: client_dh_params[:g_b_bytes]
       )
 
-      client_dh_data = client_dh_inner_data.serialize
+      client_dh_data = client_dh_inner_data.body.pack('C*')
       client_dh_data_with_hash = Digest::SHA1.digest(client_dh_data) + client_dh_data
 
       padding_length = (16 - (client_dh_data_with_hash.bytesize % 16)) % 16
@@ -200,39 +172,30 @@ module MTProto
         tmp_aes_iv
       )
 
-      body = Type::AuthKey::SetClientDHParams.build(
-        nonce: res_pq[:nonce],
-        server_nonce: res_pq[:server_nonce],
+      rpc = TL::SetClientDHParams.new(
+        nonce: res_pq.nonce,
+        server_nonce: res_pq.server_nonce,
         encrypted_data: client_dh_encrypted
       )
-      message = Type::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
-
-      @connection.send(message.serialize)
-
-      response_data = @connection.recv(timeout: @timeout)
-      response_message = Type::Message.deserialize(response_data)
-      Type::AuthKey::DHGenResponse.parse(response_message.body)
+      send_and_receive(rpc, TL::DHGenResponse)
     end
 
-    def verify_dh_gen_response(dh_gen_response, res_pq, new_nonce, auth_key)
-      raise 'Nonce mismatch in DH response!' unless dh_gen_response[:nonce] == res_pq[:nonce]
-      raise 'Server nonce mismatch in DH response!' unless dh_gen_response[:server_nonce] == res_pq[:server_nonce]
-
+    def verify_dh_gen_response(dh_gen_response, new_nonce, auth_key)
       auth_key_hash = Digest::SHA1.digest(auth_key)
       auth_key_aux_hash = auth_key_hash[0, 8]
 
-      expected_new_nonce_hash = case dh_gen_response[:status]
-      when :ok
-        Digest::SHA1.digest(new_nonce + "\x01".b + auth_key_aux_hash)[-16..]
-      when :retry
-        Digest::SHA1.digest(new_nonce + "\x02".b + auth_key_aux_hash)[-16..]
-      when :fail
-        Digest::SHA1.digest(new_nonce + "\x03".b + auth_key_aux_hash)[-16..]
-      end
+      expected_new_nonce_hash = case dh_gen_response.status
+                                when :ok
+                                  Digest::SHA1.digest(new_nonce + "\x01".b + auth_key_aux_hash)[-16..]
+                                when :retry
+                                  Digest::SHA1.digest(new_nonce + "\x02".b + auth_key_aux_hash)[-16..]
+                                when :fail
+                                  Digest::SHA1.digest(new_nonce + "\x03".b + auth_key_aux_hash)[-16..]
+                                end
 
-      raise 'new_nonce_hash mismatch!' unless dh_gen_response[:new_nonce_hash] == expected_new_nonce_hash
+      raise 'new_nonce_hash mismatch!' unless dh_gen_response.new_nonce_hash == expected_new_nonce_hash
 
-      case dh_gen_response[:status]
+      case dh_gen_response.status
       when :retry
         raise 'Server requested retry - not implemented'
       when :fail

data/lib/mtproto/binary.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Binary
+    def b_u32(bytes)
+      bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)
+    end
+
+    def b_u64(bytes)
+      b_u32(bytes[0, 4]) | (b_u32(bytes[4, 4]) << 32)
+    end
+
+    def u32_b(value)
+      [value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff]
+    end
+
+    def u64_b(value)
+      u32_b(value & 0xffffffff) + u32_b(value >> 32)
+    end
+  end
+end

data/lib/mtproto/client/api/check_password.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/get_password'
+require_relative '../../tl/objects/check_password'
+require_relative '../../tl/objects/account_password'
+require_relative '../../tl/objects/authorization'
+require_relative '../../crypto/srp'
+
+module MTProto
+  class Client
+    class API
+      def check_password(password:)
+        pwd = rpc_call(TL::GetPassword.new, TL::AccountPassword).body
+
+        raise 'Account does not have 2FA enabled' unless pwd.has_password
+
+        srp_result = Crypto::SRP.compute_check(
+          algo: pwd.current_algo,
+          srp_b: pwd.srp_b,
+          srp_id: pwd.srp_id,
+          password: password
+        )
+
+        result = rpc_call(
+          TL::CheckPassword.new(
+            srp_id: srp_result[:srp_id],
+            a: srp_result[:a],
+            m1: srp_result[:m1]
+          ),
+          TL::Authorization
+        ).body
+
+        if result.authorization? && result.user_id
+          @client.update_user(user_id: result.user_id, access_hash: result.access_hash)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/export_login_token.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/export_login_token'
+require_relative '../../tl/objects/login_token'
+
+module MTProto
+  class Client
+    class API
+      def export_login_token(except_ids: [])
+        result = rpc_call(
+          TL::ExportLoginToken.new(
+            api_id: @client.api_id,
+            api_hash: @client.api_hash,
+            except_ids: except_ids
+          ),
+          TL::LoginToken
+        ).body
+
+        if result.success? && result.user_id
+          @client.update_user(user_id: result.user_id, access_hash: result.access_hash)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/get_updates_difference.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/get_difference'
+require_relative '../../tl/objects/updates_difference'
+
+module MTProto
+  class Client
+    class API
+      def get_updates_difference(pts:, date:, qts:, pts_limit: nil, qts_limit: nil, pts_total_limit: nil)
+        rpc_call(
+          TL::GetDifference.new(
+            pts: pts, date: date, qts: qts,
+            pts_limit: pts_limit, qts_limit: qts_limit,
+            pts_total_limit: pts_total_limit
+          ),
+          TL::UpdatesDifference
+        ).body
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/get_updates_state.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/get_state'
+require_relative '../../tl/objects/updates_state'
+
+module MTProto
+  class Client
+    class API
+      def get_updates_state
+        rpc_call(TL::GetState.new, TL::UpdatesState).body
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/get_users.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/get_users'
+require_relative '../../tl/objects/users'
+
+module MTProto
+  class Client
+    class API
+      def get_users
+        rpc_call(TL::GetUsers.new, TL::Users).body
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/import_login_token.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/import_login_token'
+require_relative '../../tl/objects/login_token'
+
+module MTProto
+  class Client
+    class API
+      def import_login_token(token:)
+        result = rpc_call(
+          TL::ImportLoginToken.new(token: token),
+          TL::LoginToken
+        ).body
+
+        if result.success? && result.user_id
+          @client.update_user(user_id: result.user_id, access_hash: result.access_hash)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/send_code.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/send_code'
+require_relative '../../tl/objects/sent_code'
+
+module MTProto
+  class Client
+    class API
+      def send_code(phone_number)
+        rpc_call(
+          TL::SendCode.new(
+            phone_number: phone_number,
+            api_id: @client.api_id,
+            api_hash: @client.api_hash
+          ),
+          TL::SentCode
+        ).body
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/sign_in.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/sign_in'
+require_relative '../../tl/objects/authorization'
+
+module MTProto
+  class Client
+    class API
+      def sign_in(phone_number:, phone_code_hash:, phone_code:)
+        result = rpc_call(
+          TL::SignIn.new(
+            phone_number: phone_number,
+            phone_code_hash: phone_code_hash,
+            phone_code: phone_code
+          ),
+          TL::Authorization
+        ).body
+
+        if result.authorization? && result.user_id
+          @client.update_user(user_id: result.user_id, access_hash: result.access_hash)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/mtproto/client/api.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'api/send_code'
+require_relative 'api/sign_in'
+require_relative 'api/export_login_token'
+require_relative 'api/import_login_token'
+require_relative 'api/check_password'
+require_relative 'api/get_users'
+require_relative 'api/get_updates_state'
+require_relative 'api/get_updates_difference'
+
+module MTProto
+  class Client
+    class API
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      def rpc_call(request, response_class)
+        response = @client.rpc.call(request, response_class)
+        response.wait!(@client.timeout)
+        response
+      end
+    end
+  end
+end

data/lib/mtproto/client/rpc/response.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'async/condition'
+
+module MTProto
+  class Client
+    class RPC
+      class Response
+        attr_reader :msg_id, :body_bytes, :response_class
+
+        def initialize(msg_id, response_class, body_bytes)
+          @msg_id = msg_id
+          @response_class = response_class
+          @body_bytes = body_bytes
+          @condition = ::Async::Condition.new
+          @result = nil
+          @error = nil
+        end
+
+        def received?
+          !@result.nil? || !@error.nil?
+        end
+
+        def wait!(timeout = nil)
+          unless received?
+            if timeout
+              ::Async::Task.current.with_timeout(timeout) { receive_signal }
+            else
+              receive_signal
+            end
+          end
+
+          raise @error if @error
+
+          @result
+        end
+
+        def body
+          raise 'Response not received yet' unless received?
+          raise @error if @error
+
+          @result
+        end
+
+        def signal(raw_body)
+          @result = @response_class.parse(raw_body)
+          @condition.signal
+        end
+
+        def signal_error(error)
+          @error = error
+          @condition.signal
+        end
+
+        private
+
+        def receive_signal
+          @condition.wait
+        end
+      end
+    end
+  end
+end