mtproto 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4f29435603981ebe49a049987b68aa7423336b2ed6831ee8831dc40e84fa4dc
-  data.tar.gz: e1cc58e26a988579389807bf8a7e5c03a5c7ba758d7eb0193e961e7ebf78b412
+  metadata.gz: 414d6f7ed0a5c1c20c5108844469daafff2af7d2c350c8370b2eb6cec73068fe
+  data.tar.gz: d7c8e3397861bdc4f9d3c695ba884a672698f39c051c06271e5e39dcdf0aa7bd
 SHA512:
-  metadata.gz: 419f2ae43af6c8248c45d4e80d6e1451e9767018a236df01f67765feb16dae45d2d9f0c4563735dda5afca3daf135d1cd4bbce4423262e4631914b7624c50230
-  data.tar.gz: '032386a5ae69e7126a7047b427f67c0fb533cb6ac7f7a19193292c4185f5efca126d967329b50dc6476d1a1655f675e1079312104113d9cf328683cfb038a0f5'
+  metadata.gz: 2ccbe16eaf853697c6267ebe6b84e8593c071a66d95de9b1a1be1cafb0e33317400fb52fe85ef7aec43da2aa69bbc3f4cbc55af25928116711518925f4ed7897
+  data.tar.gz: 9658e4c8bd82fed68fd43f40e35efb1a57742170d27aa5f6a641528628e6da0013dfa9ddb632f42cb6e5418cd82c3006b8a4624294ebc40567c08d636aeae96b

data/lib/mtproto/client.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'transport/tcp_connection'
+require_relative 'transport/abridged_packet_codec'
+require_relative 'tl/message'
+
+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
+
+    attr_reader :connection
+
+    def initialize(dc_id: 2)
+      host, port = DC_ADDRESSES[dc_id]
+      raise ArgumentError, "Unknown DC ID: #{dc_id}" unless host
+
+      codec = Transport::AbridgedPacketCodec.new
+      @connection = Transport::TCPConnection.new(host, port, codec)
+    end
+
+    def connect
+      @connection.connect
+    end
+
+    def disconnect
+      @connection.close
+    end
+
+    def req_pq_multi
+      nonce = SecureRandom.random_bytes(16)
+
+      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
+
+      rsa_key = Crypto::RSAKey.find_by_fingerprint(res_pq[:fingerprints])
+      raise 'No matching RSA key found!' unless rsa_key
+
+      res_pq[:rsa_key] = rsa_key
+      res_pq
+    end
+  end
+end

data/lib/mtproto/crypto/rsa_key.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'openssl'
+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)
+        @key = OpenSSL::PKey::RSA.new(pem_string)
+        @fingerprint = calculate_fingerprint
+      end
+
+      def self.telegram_key
+        @telegram_key ||= new(TELEGRAM_KEY)
+      end
+
+      def self.find_by_fingerprint(fingerprints)
+        telegram_key if fingerprints.include?(telegram_key.fingerprint)
+      end
+
+      private
+
+      def calculate_fingerprint
+        n_bytes = @key.n.to_s(2).unpack1('B*').scan(/.{8}/).map { |b| b.to_i(2) }.pack('C*')
+        e_bytes = @key.e.to_s(2).unpack1('B*').scan(/.{8}/).map { |b| b.to_i(2) }.pack('C*')
+
+        n_tl = serialize_bytes(n_bytes)
+        e_tl = serialize_bytes(e_bytes)
+
+        data = n_tl + e_tl
+        sha1 = Digest::SHA1.digest(data)
+
+        sha1[-8..].unpack1('Q<')
+      end
+
+      def serialize_bytes(bytes)
+        length = bytes.bytesize
+
+        if length <= 253
+          [length].pack('C') + bytes + padding(length + 1)
+        else
+          [254].pack('C') + [length].pack('L<')[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        "\x00" * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/message.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Message
+      CONSTRUCTOR_REQ_PQ_MULTI = 0xbe7e8ef1
+      CONSTRUCTOR_RES_PQ = 0x05162463
+
+      attr_reader :auth_key_id, :msg_id, :body
+
+      def initialize(auth_key_id: 0, msg_id: nil, body: '')
+        @auth_key_id = auth_key_id
+        @msg_id = msg_id || generate_msg_id
+        @body = body
+      end
+
+      def serialize
+        auth_key_id_bytes = [@auth_key_id].pack('Q<')
+        msg_id_bytes = [@msg_id].pack('Q<')
+        body_length = [@body.bytesize].pack('L<')
+
+        auth_key_id_bytes + msg_id_bytes + body_length + @body
+      end
+
+      def self.req_pq_multi(nonce)
+        raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
+
+        constructor = [CONSTRUCTOR_REQ_PQ_MULTI].pack('L<')
+        body = constructor + nonce
+
+        new(auth_key_id: 0, body: body)
+      end
+
+      def self.deserialize(data)
+        auth_key_id = data[0, 8].unpack1('Q<')
+        msg_id = data[8, 8].unpack1('Q<')
+        body_length = data[16, 4].unpack1('L<')
+        body = data[20, body_length]
+
+        new(auth_key_id: auth_key_id, msg_id: msg_id, body: body)
+      end
+
+      def parse_res_pq
+        constructor = @body[0, 4].unpack1('L<')
+        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR_RES_PQ
+
+        offset = 4
+
+        nonce = @body[offset, 16]
+        offset += 16
+
+        server_nonce = @body[offset, 16]
+        offset += 16
+
+        pq_length_byte = @body[offset].unpack1('C')
+        offset += 1
+
+        pq_length = if pq_length_byte == 254
+          @body[offset, 3].unpack1('L<') & 0xffffff
+          offset += 3
+        else
+          pq_length_byte
+        end
+
+        pq = @body[offset, pq_length]
+        offset += pq_length
+        offset += padding_length(pq_length + 1)
+
+        vector_constructor = @body[offset, 4].unpack1('L<')
+        offset += 4
+        raise 'Expected vector constructor' unless vector_constructor == 0x1cb5c415
+
+        fingerprints_count = @body[offset, 4].unpack1('L<')
+        offset += 4
+
+        fingerprints = []
+        fingerprints_count.times do
+          fingerprints << @body[offset, 8].unpack1('Q<')
+          offset += 8
+        end
+
+        {
+          nonce: nonce,
+          server_nonce: server_nonce,
+          pq: pq,
+          fingerprints: fingerprints
+        }
+      end
+
+      private
+
+      def generate_msg_id
+        time_ns = (Time.now.to_f * 1_000_000_000).to_i
+        (time_ns / 4) * 4
+      end
+
+      def padding_length(length)
+        (4 - (length % 4)) % 4
+      end
+
+      def self.padding_length(length)
+        (4 - (length % 4)) % 4
+      end
+    end
+  end
+end

data/lib/mtproto/transport/tcp_connection.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'timeout'
+
+module MTProto
+  module Transport
+    class ConnectionError < StandardError; end
+
+    class TCPConnection
+      attr_reader :host, :port, :codec
+
+      def initialize(host, port, codec)
+        @host = host
+        @port = port
+        @codec = codec
+        @socket = nil
+      end
+
+      def connect
+        return if connected?
+
+        @socket = TCPSocket.new(@host, @port)
+
+        send_init_tag if @codec.class.const_defined?(:TAG)
+      end
+
+      def connected?
+        !@socket.nil? && !@socket.closed?
+      end
+
+      def send(data)
+        raise ConnectionError, 'Not connected' unless connected?
+
+        encoded = @codec.encode_packet(data)
+        @socket.write(encoded)
+      end
+
+      def recv(timeout: 60)
+        raise ConnectionError, 'Not connected' unless connected?
+
+        Timeout.timeout(timeout) do
+          read_packet
+        end
+      rescue Timeout::Error
+        raise ConnectionError, 'Receive timeout'
+      end
+
+      def close
+        return unless @socket
+
+        @socket.close
+      rescue StandardError
+        nil
+      ensure
+        @socket = nil
+      end
+
+      private
+
+      def send_init_tag
+        tag = @codec.class.const_get(:TAG)
+        @socket.write(tag) if tag
+      end
+
+      def read_packet
+        first_byte = read_exactly(1)
+        length = first_byte.unpack1('C')
+
+        if length >= 127
+          length_bytes = read_exactly(3)
+          length = (length_bytes + "\x00").unpack1('L<')
+        end
+
+        actual_length = length << 2
+        read_exactly(actual_length)
+      end
+
+      def read_exactly(bytes_needed)
+        result = ''.b
+        while result.bytesize < bytes_needed
+          chunk = @socket.read(bytes_needed - result.bytesize)
+          raise ConnectionError, 'EOF while reading' if chunk.nil? || chunk.empty?
+
+          result += chunk
+        end
+        result
+      end
+    end
+  end
+end

data/lib/mtproto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MTProto
-  VERSION = '0.0.2'
+  VERSION = '0.0.4'
 end

data/lib/mtproto.rb

@@ -2,6 +2,10 @@
 
 require_relative 'mtproto/version'
 require_relative 'mtproto/transport/abridged_packet_codec'
+require_relative 'mtproto/transport/tcp_connection'
+require_relative 'mtproto/tl/message'
+require_relative 'mtproto/crypto/rsa_key'
+require_relative 'mtproto/client'
 
 module MTProto
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mtproto
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Artem Levenkov
@@ -20,7 +20,11 @@ files:
 - ".ruby-version"
 - Rakefile
 - lib/mtproto.rb
+- lib/mtproto/client.rb
+- lib/mtproto/crypto/rsa_key.rb
+- lib/mtproto/tl/message.rb
 - lib/mtproto/transport/abridged_packet_codec.rb
+- lib/mtproto/transport/tcp_connection.rb
 - lib/mtproto/version.rb
 homepage: https://github.com/alev-pro/mtproto-ruby
 licenses: