mtproto 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd33fd4bcb039dfffa0a6d2c2193e05fdf306a24c8f34a09b197d8aa45dd9117
-  data.tar.gz: 2061be3cf7378f0b86cff34eae3c34fa025bfdb252f61bc99307489437b9ab63
+  metadata.gz: 2744b720c59f90c3e9d18021ce6096a1c8e559dae949fbd6a9b53948c14f8b5c
+  data.tar.gz: 3b9000cabc247db305244b279bc58474466e1549cca3efa07ca1202eaa2d7874
 SHA512:
-  metadata.gz: cb9c3c9c4d59755b3e4693e475f51295476caaeb932239439ff8e0940484bb8fe0dd3420282fd6d2f807b8da6755737ece84d0bf464bd5554e6190dcdebc3845
-  data.tar.gz: dad6e992b30ca7a7e9a20f9d027bd6436a6b90ab6721a45cb36b8ff3080d4e58633d1d50aa2a54c41568a048e93f7b2b9badc4fd7ad3fd361416a3b428da1b18
+  metadata.gz: 874a17be8f75bb305057d0a0cb2c136441f9e8da883c44a99169ad0975c5b745b4323abc84ab6edb96b72f2c8f500ec40536a1a6724f585730501514a2e7475b
+  data.tar.gz: 6a693436a7443f789cb73a6fe6ecebf523ee288bb174b297fdfac4274340c9a5a00544299d08f0558028645e4cf80dbfb0c70c844ec47d2bb6e413589a45a5b2

data/.env.example

@@ -0,0 +1,5 @@
+TG_API_ID=your_api_id
+TG_API_HASH=your_api_hash
+TG_TEST_DC='111.111.111.111:443'
+TG_TEST_DC_N='1'
+TG_TEST_DC_KEY='DC public key'

data/Rakefile

@@ -14,7 +14,20 @@ end
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = '--require spec_helper'
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:unit') do |t|
+  t.rspec_opts = '--require spec_helper'
+  t.pattern = 'spec/lib/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:integration') do |t|
+  t.rspec_opts = '--require spec_helper'
+  t.pattern = 'spec/integration/**/*_spec.rb'
 end
 
 task spec: :compile
+task 'spec:unit': :compile
+task 'spec:integration': :compile
 task default: :spec

data/lib/mtproto/auth_key_generator.rb

@@ -2,13 +2,27 @@
 
 require 'securerandom'
 require 'digest'
+require_relative 'message_id'
+require_relative 'tl/auth_key/req_pq_multi'
+require_relative 'tl/auth_key/res_pq'
+require_relative 'tl/auth_key/req_dh_params'
+require_relative 'tl/auth_key/server_dh_params'
+require_relative 'tl/auth_key/set_client_dh_params'
+require_relative 'tl/auth_key/dh_gen_response'
 
 module MTProto
   class AuthKeyGenerator
-    attr_reader :connection, :auth_key, :server_salt, :time_offset
+    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
 
-    def initialize(connection)
       @connection = connection
+      @public_key = public_key
+      @dc_number = dc_number
+      @test_mode = test_mode
+      @timeout = timeout
       @auth_key = nil
       @server_salt = nil
       @time_offset = 0
@@ -73,12 +87,13 @@ module MTProto
 
     def req_pq_multi
       nonce = SecureRandom.random_bytes(16)
-      message = TL::Message.req_pq_multi(nonce)
+      body = TL::AuthKey::ReqPqMulti.build(nonce)
+      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
       @connection.send(message.serialize)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
-      res_pq = response_message.parse_res_pq
+      res_pq = TL::AuthKey::ResPq.parse(response_message.body)
 
       raise 'Nonce mismatch!' unless res_pq[:nonce] == nonce
 
@@ -86,13 +101,19 @@ module MTProto
     end
 
     def find_server_key(fingerprints)
-      server_key = Crypto::RSAKey.find_by_fingerprint(fingerprints)
+      server_key = Crypto::RSAKey.find_by_fingerprint(fingerprints, @public_key)
       raise 'No matching RSA key found!' unless server_key
 
       server_key
     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?
+
+      # 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
+
       inner_data = TL::PQInnerData.new(
         pq: Crypto::Factorization.bytes_to_integer(res_pq[:pq]),
         p: p,
@@ -100,14 +121,14 @@ module MTProto
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         new_nonce: new_nonce,
-        dc: @connection.port == 443 ? 2 : 1
+        dc: dc_value
       )
 
       Crypto::RSA_PAD.encrypt(inner_data.serialize, server_key)
     end
 
     def send_req_dh_params(res_pq, p, q, server_key, encrypted_data)
-      message = TL::Message.req_DH_params(
+      body = TL::AuthKey::ReqDHParams.build(
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         p: p,
@@ -115,12 +136,13 @@ module MTProto
         public_key_fingerprint: server_key.fingerprint,
         encrypted_data: encrypted_data
       )
+      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
 
       @connection.send(message.serialize)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
-      server_dh_params = response_message.parse_server_DH_params_ok
+      server_dh_params = TL::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]
@@ -178,17 +200,18 @@ module MTProto
         tmp_aes_iv
       )
 
-      message = TL::Message.set_client_DH_params(
+      body = TL::AuthKey::SetClientDHParams.build(
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         encrypted_data: client_dh_encrypted
       )
+      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
 
       @connection.send(message.serialize)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
-      response_message.parse_dh_gen_response
+      TL::AuthKey::DHGenResponse.parse(response_message.body)
     end
 
     def verify_dh_gen_response(dh_gen_response, res_pq, new_nonce, auth_key)

data/lib/mtproto/client/rpc.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../message_id'
+
+module MTProto
+  class Client
+    class RPC
+      CONSTRUCTOR_RPC_RESULT = 0xf35c6d01
+      CONSTRUCTOR_MSGS_ACK = 0x62d6b459
+      CONSTRUCTOR_BAD_SERVER_SALT = 0xedab447b
+
+      def initialize(client)
+        @client = client
+        @connection_initialized = false
+      end
+
+      def call(body, content_related: true)
+        raise 'Auth key not generated' unless @client.auth_key
+        raise 'Session not initialized' unless @client.session
+
+        msg_id = MessageId.generate(time_offset: @client.time_offset)
+        seq_no = @client.session.next_seq_no(content_related: content_related)
+
+        encrypted_msg = EncryptedMessage.encrypt(
+          auth_key: @client.auth_key,
+          server_salt: @client.server_salt,
+          session_id: @client.session.session_id,
+          msg_id: msg_id,
+          seq_no: seq_no,
+          body: body
+        )
+
+        @client.connection.send(encrypted_msg.serialize)
+
+        response_data = @client.connection.recv(timeout: @client.timeout)
+
+        decrypted = EncryptedMessage.decrypt(
+          auth_key: @client.auth_key,
+          encrypted_message_data: response_data,
+          sender: :server
+        )
+
+        response_body = decrypted[:body]
+
+        constructor = response_body[0, 4].unpack1('L<')
+
+        # Handle bad_server_salt
+        if constructor == CONSTRUCTOR_BAD_SERVER_SALT
+          # bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int error_code:int new_server_salt:long
+          offset = 4
+          bad_msg_id = response_body[offset, 8].unpack1('Q<')
+          offset += 8
+          bad_msg_seqno = response_body[offset, 4].unpack1('L<')
+          offset += 4
+          error_code = response_body[offset, 4].unpack1('L<')
+          offset += 4
+          new_server_salt = response_body[offset, 8].unpack1('Q<')
+
+          # Update server salt and retry
+          update_server_salt(new_server_salt)
+          return call(body, content_related: content_related)
+        end
+
+        if constructor == TL::NewSessionCreated::CONSTRUCTOR
+          session_info = TL::NewSessionCreated.deserialize(response_body)
+          update_server_salt(session_info.server_salt)
+
+          response_data = @client.connection.recv(timeout: @client.timeout)
+          decrypted = EncryptedMessage.decrypt(
+            auth_key: @client.auth_key,
+            encrypted_message_data: response_data,
+            sender: :server
+          )
+          response_body = decrypted[:body]
+          constructor = response_body[0, 4].unpack1('L<')
+        end
+
+        if constructor == TL::MsgContainer::CONSTRUCTOR
+          container = TL::MsgContainer.deserialize(response_body)
+
+          rpc_result = container.messages.find do |msg|
+            msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_RPC_RESULT
+          end
+
+          return rpc_result[:body][12..] if rpc_result
+
+          new_session = container.messages.find do |msg|
+            msg[:body][0, 4].unpack1('L<') == TL::NewSessionCreated::CONSTRUCTOR
+          end
+          if new_session
+            session_info = TL::NewSessionCreated.deserialize(new_session[:body])
+            update_server_salt(session_info.server_salt)
+
+            other_messages = container.messages.reject do |msg|
+              constructor = msg[:body][0, 4].unpack1('L<')
+              (
+                constructor == TL::NewSessionCreated::CONSTRUCTOR ||
+                constructor == CONSTRUCTOR_MSGS_ACK
+              )
+            end
+
+            return other_messages.first[:body] unless other_messages.empty?
+
+            response_data = @client.connection.recv(timeout: @client.timeout)
+            decrypted = EncryptedMessage.decrypt(
+              auth_key: @client.auth_key,
+              encrypted_message_data: response_data,
+              sender: :server
+            )
+            response_body = decrypted[:body]
+            constructor = response_body[0, 4].unpack1('L<')
+
+            return response_body[12..] if constructor == CONSTRUCTOR_RPC_RESULT
+
+            if constructor == TL::MsgContainer::CONSTRUCTOR
+              container = TL::MsgContainer.deserialize(response_body)
+              rpc_result = container.messages.find do |msg|
+                msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_RPC_RESULT
+              end
+              return rpc_result[:body][12..] if rpc_result
+            end
+
+            return response_body
+          end
+
+          return container.messages.first[:body]
+        end
+
+        return response_body[12..] if constructor == CONSTRUCTOR_RPC_RESULT
+
+        response_body
+      end
+
+      private
+
+      def update_server_salt(server_salt)
+        @client.instance_variable_set(:@server_salt, server_salt)
+      end
+    end
+  end
+end

data/lib/mtproto/client.rb

@@ -2,64 +2,62 @@
 
 require 'securerandom'
 require 'digest'
+require 'base64'
 require_relative 'transport/tcp_connection'
 require_relative 'transport/abridged_packet_codec'
 require_relative 'tl/message'
+require_relative 'client/rpc'
+require_relative 'tl/method_builder'
 
 module MTProto
   class Client
-    DC_ADDRESSES = {
-      1 => ['149.154.175.50', 443],
-      2 => ['149.154.167.51', 443],
-      3 => ['149.154.175.100', 443],
-      4 => ['149.154.167.91', 443],
-      5 => ['91.108.56.130', 443]
-    }.freeze
+    include TL::MethodBuilder
 
-    attr_reader :connection, :server_key, :auth_key, :server_salt, :time_offset, :session
+    attr_reader :connection, :server_key, :auth_key, :server_salt, :time_offset, :session, :timeout, :user_id, :access_hash, :dc_number
+    attr_accessor :api_id, :api_hash, :device_model, :system_version, :app_version, :system_lang_code, :lang_pack, :lang_code
 
-    def initialize(dc_id: 2)
-      host, port = DC_ADDRESSES[dc_id]
-      raise ArgumentError, "Unknown DC ID: #{dc_id}" unless host
+    def initialize(api_id: nil, api_hash: nil, host:, port: 443, public_key: nil, dc_number: nil, test_mode: false, timeout: 10)
+      raise ArgumentError, "host is required" if host.nil? || host.empty?
+      raise ArgumentError, "dc_number must be positive. Use test_mode: true for test DCs" if dc_number && dc_number < 0
 
       codec = Transport::AbridgedPacketCodec.new
       @connection = Transport::TCPConnection.new(host, port, codec)
+      @public_key = public_key
+      @dc_number = dc_number
+      @test_mode = test_mode
+      @timeout = timeout
       @server_key = nil
       @auth_key = nil
       @server_salt = nil
       @time_offset = 0
       @session = nil
       @connection_initialized = false
+      @user_id = nil
+      @access_hash = nil
+
+      # Client configuration defaults
+      @api_id = api_id || 0
+      @api_hash = api_hash || ''
+      @device_model = 'Ruby MTProto'
+      @system_version = RUBY_DESCRIPTION
+      @app_version = '0.1.0'
+      @system_lang_code = 'en'
+      @lang_pack = ''
+      @lang_code = 'en'
     end
 
-    def connect
-      @connection.connect
+    def connect!
+      @connection.connect!
     end
 
-    def disconnect
-      @connection.close
+    def disconnect!
+      @connection.close if @connection
     end
 
-    def req_pq_multi
-      nonce = SecureRandom.random_bytes(16)
+    def exchange_keys!
+      raise ArgumentError, "public_key is required for auth key generation" if @public_key.nil? || @public_key.empty?
 
-      message = TL::Message.req_pq_multi(nonce)
-      payload = message.serialize
-
-      @connection.send(payload)
-
-      response_data = @connection.recv(timeout: 10)
-      response_message = TL::Message.deserialize(response_data)
-
-      res_pq = response_message.parse_res_pq
-
-      raise 'Nonce mismatch!' unless res_pq[:nonce] == nonce
-
-      res_pq
-    end
-
-    def make_auth_key
-      generator = AuthKeyGenerator.new(@connection)
+      generator = AuthKeyGenerator.new(@connection, @public_key, @dc_number, test_mode: @test_mode, timeout: @timeout)
       result = generator.generate
 
       @auth_key = generator.auth_key
@@ -70,166 +68,43 @@ module MTProto
       result
     end
 
-    def generate_msg_id
-      time = Time.now.to_f + @time_offset
-      msg_id = (time * (2**32)).to_i
-      (msg_id / 4) * 4
+    def rpc
+      @rpc ||= RPC.new(self)
     end
 
-    def rpc_call(body, content_related: true)
-      raise 'Auth key not generated' unless @auth_key
-      raise 'Session not initialized' unless @session
-
-      msg_id = generate_msg_id
-      seq_no = @session.next_seq_no(content_related: content_related)
+    def save_session
+      raise 'Cannot save session: auth_key not set' unless @auth_key
 
-      encrypted_msg = EncryptedMessage.encrypt(
-        auth_key: @auth_key,
+      {
+        auth_key: Base64.strict_encode64(@auth_key),
         server_salt: @server_salt,
-        session_id: @session.session_id,
-        msg_id: msg_id,
-        seq_no: seq_no,
-        body: body
-      )
-
-      @connection.send(encrypted_msg.serialize)
-
-      response_data = @connection.recv(timeout: 10)
-
-      decrypted = EncryptedMessage.decrypt(
-        auth_key: @auth_key,
-        encrypted_message_data: response_data,
-        sender: :server
-      )
-
-      response_body = decrypted[:body]
-
-      constructor = response_body[0, 4].unpack1('L<')
-      puts "  [RPC] First response constructor: 0x#{constructor.to_s(16)} (#{response_body.bytesize} bytes)"
-
-      if constructor == TL::NewSessionCreated::CONSTRUCTOR
-        puts "  [RPC] Got new_session_created, waiting for actual response..."
-        session_info = TL::NewSessionCreated.deserialize(response_body)
-        @server_salt = session_info.server_salt
-        puts "  [RPC] Updated server_salt to: 0x#{@server_salt.to_s(16)}"
-
-        response_data = @connection.recv(timeout: 10)
-        puts "  [RPC] Second response received (#{response_data.bytesize} bytes encrypted)"
-        decrypted = EncryptedMessage.decrypt(
-          auth_key: @auth_key,
-          encrypted_message_data: response_data,
-          sender: :server
-        )
-        response_body = decrypted[:body]
-        constructor = response_body[0, 4].unpack1('L<')
-        puts "  [RPC] Second response constructor: 0x#{constructor.to_s(16)} (#{response_body.bytesize} bytes)"
-      end
-
-      if constructor == TL::Message::CONSTRUCTOR_MSG_CONTAINER
-        puts "  [RPC] Response is a container, unpacking..."
-        container = TL::MsgContainer.deserialize(response_body)
-        puts "  [RPC] Container has #{container.messages.size} messages"
-
-        container.messages.each_with_index do |msg, i|
-          msg_constructor = msg[:body][0, 4].unpack1('L<')
-          puts "  [RPC]   Message #{i}: constructor=0x#{msg_constructor.to_s(16)}, size=#{msg[:body].bytesize}"
-        end
-
-        rpc_result = container.messages.find do |msg|
-          msg[:body][0, 4].unpack1('L<') == 0xf35c6d01
-        end
-
-        if rpc_result
-          puts "  [RPC] Found rpc_result in container, extracting..."
-          return rpc_result[:body][12..]
-        end
-
-        new_session = container.messages.find { |msg| msg[:body][0, 4].unpack1('L<') == TL::NewSessionCreated::CONSTRUCTOR }
-        if new_session
-          puts "  [RPC] Container has new_session_created, updating salt and waiting for RPC result..."
-          session_info = TL::NewSessionCreated.deserialize(new_session[:body])
-          @server_salt = session_info.server_salt
-          puts "  [RPC] Updated server_salt to: 0x#{@server_salt.to_s(16)}"
-
-          response_data = @connection.recv(timeout: 10)
-          puts "  [RPC] Next response received (#{response_data.bytesize} bytes encrypted)"
-          decrypted = EncryptedMessage.decrypt(
-            auth_key: @auth_key,
-            encrypted_message_data: response_data,
-            sender: :server
-          )
-          response_body = decrypted[:body]
-          constructor = response_body[0, 4].unpack1('L<')
-          puts "  [RPC] Next response constructor: 0x#{constructor.to_s(16)} (#{response_body.bytesize} bytes)"
-
-          if constructor == 0xf35c6d01
-            puts "  [RPC] Next response is rpc_result, extracting payload..."
-            return response_body[12..]
-          end
-
-          if constructor == TL::Message::CONSTRUCTOR_MSG_CONTAINER
-            puts "  [RPC] Next response is also a container, looking for rpc_result..."
-            container = TL::MsgContainer.deserialize(response_body)
-            rpc_result = container.messages.find { |msg| msg[:body][0, 4].unpack1('L<') == 0xf35c6d01 }
-            return rpc_result[:body][12..] if rpc_result
-          end
-
-          return response_body
-        end
-
-        puts "  [RPC] No rpc_result found, returning first message body"
-        return container.messages.first[:body]
-      end
-
-      if constructor == 0xf35c6d01
-        puts "  [RPC] Response is rpc_result, extracting payload..."
-        return response_body[12..]
-      end
-
-      puts "  [RPC] Returning raw response body (constructor: 0x#{constructor.to_s(16)})"
-      response_body
+        user_id: @user_id,
+        access_hash: @access_hash,
+        dc_number: @dc_number,
+        time_offset: @time_offset
+      }
     end
 
-    def invoke_with_layer(layer, query)
-      body = TL::Serializer.serialize_int(0xda9b0d0d)
-      body += TL::Serializer.serialize_int(layer)
-      body += query
-      body
-    end
+    def load_session(session_data)
+      raise ArgumentError, 'session_data must be a Hash' unless session_data.is_a?(Hash)
+      raise ArgumentError, 'auth_key is required' unless session_data[:auth_key]
+      raise ArgumentError, 'server_salt is required' unless session_data[:server_salt]
+
+      @auth_key = Base64.strict_decode64(session_data[:auth_key])
+      @server_salt = session_data[:server_salt]
+      @time_offset = session_data[:time_offset] || 0
+      @user_id = session_data[:user_id]
+      @access_hash = session_data[:access_hash]
+
+      # Create a fresh session for the new connection
+      @session = Session.new
 
-    def init_connection(api_id, device_model, system_version, app_version, system_lang_code, lang_code, query)
-      body = TL::Serializer.serialize_int(0xc1cd5ea9)
-      flags = 0
-      body += TL::Serializer.serialize_int(flags)
-      body += TL::Serializer.serialize_int(api_id)
-      body += TL::Serializer.serialize_string(device_model)
-      body += TL::Serializer.serialize_string(system_version)
-      body += TL::Serializer.serialize_string(app_version)
-      body += TL::Serializer.serialize_string(system_lang_code)
-      body += TL::Serializer.serialize_string('')
-      body += TL::Serializer.serialize_string(lang_code)
-      body += query
-      body
+      true
     end
 
-    def help_get_config
-      query = [0xc4f9186b].pack('L<')
-
-      unless @connection_initialized
-        query = init_connection(
-          123456,
-          'Ruby MTProto',
-          'Ruby 3.x',
-          '0.1.0',
-          'en',
-          'en',
-          query
-        )
-        query = invoke_with_layer(214, query)
-        @connection_initialized = true
-      end
-
-      rpc_call(query)
+    def update_user(user_id:, access_hash: nil)
+      @user_id = user_id
+      @access_hash = access_hash
     end
   end
 end

data/lib/mtproto/crypto/aes_ige.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 begin
-  require 'aes_ige/aes_ige'
+  require 'aes_ige'
 rescue LoadError => e
   warn "Failed to load AES-IGE C extension: #{e.message}"
   warn 'Run: cd ext/aes_ige && ruby extconf.rb && make'

data/lib/mtproto/crypto/factorization.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 begin
-  require 'factorization/factorization'
+  require 'factorization'
 rescue LoadError => e
   warn "Failed to load Factorization C extension: #{e.message}"
   warn 'Run: cd ext/factorization && ruby extconf.rb && make'

data/lib/mtproto/crypto/rsa_key.rb

@@ -6,30 +6,24 @@ require 'digest'
 module MTProto
   module Crypto
     class RSAKey
-      TELEGRAM_KEY = <<~PEM
-        -----BEGIN RSA PUBLIC KEY-----
-        MIIBCgKCAQEA6LszBcC1LGzyr992NzE0ieY+BSaOW622Aa9Bd4ZHLl+TuFQ4lo4g
-        5nKaMBwK/BIb9xUfg0Q29/2mgIR6Zr9krM7HjuIcCzFvDtr+L0GQjae9H0pRB2OO
-        62cECs5HKhT5DZ98K33vmWiLowc621dQuwKWSQKjWf50XYFw42h21P2KXUGyp2y/
-        +aEyZ+uVgLLQbRA1dEjSDZ2iGRy12Mk5gpYc397aYp438fsJoHIgJ2lgMv5h7WY9
-        t6N/byY9Nw9p21Og3AoXSL2q/2IJ1WRUhebgAdGVMlV1fkuOQoEzR7EdpqtQD9Cs
-        5+bfo3Nhmcyvk5ftB0WkJ9z6bNZ7yxrP8wIDAQAB
-        -----END RSA PUBLIC KEY-----
-      PEM
-
       attr_reader :key, :fingerprint
 
       def initialize(pem_string)
+        raise ArgumentError, "pem_string is required" if pem_string.nil? || pem_string.empty?
+
         @key = OpenSSL::PKey::RSA.new(pem_string)
         @fingerprint = calculate_fingerprint
       end
 
-      def self.telegram_key
-        @telegram_key ||= new(TELEGRAM_KEY)
+      def self.from_pem(pem_string)
+        new(pem_string)
       end
 
-      def self.find_by_fingerprint(fingerprints)
-        telegram_key if fingerprints.include?(telegram_key.fingerprint)
+      def self.find_by_fingerprint(fingerprints, public_key)
+        raise ArgumentError, "public_key is required" if public_key.nil? || public_key.empty?
+
+        key = new(public_key)
+        key if fingerprints.include?(key.fingerprint)
       end
 
       private