steamrb 0.1.0

data/lib/steam/crypto.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+require 'openssl'
+require 'zlib'
+require 'base64'
+
+module Steam
+  # Handles Steam AES key encryption and decrptyion of raw packet data.
+  class Crypto
+    # The Steam public key
+    KEY = 'MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQDf7BrWLBBmLBc1OhSwfFkRf53'\
+          'T2Ct64+AVzRkeRuh7h3SiGEYxqQMUeYKO6UWiSRKpI2hzic9pobFhRr3Bvr/WARvY'\
+          'gdTckPv+T1JzZsuVcNfFjrocejN1oWI0Rrtgt4Bo+hOneoo3S57G9F1fOpn5nsQ66'\
+          'WOiu4gZKODnFMBCiQIBEQ=='
+
+    # Encrypt a given string with a given key, get the encrypted data back.
+    #
+    # @param data [String] the data to encrypt
+    # @param key [String] the key to encrypt the data with
+    def self.encrypt(data, key)
+      new.encrypt(StringIO.new(data), key).string
+    end
+
+    # Decrypt a given string with a given key, get the decrypted data back.
+    #
+    # @param data [String] the data to decrypt
+    # @param key [String] the key to decrypt the data with
+    def self.decrypt(data, key)
+      new.decrypt(StringIO.new(data), key).string
+    end
+
+    # Generates a tuple representing the session key, both plain text and
+    # encrypted
+    #
+    # @example Generating a key
+    #   crypto = Cyrpto.new
+    #   crypted_key, key = crypto.generate_key
+    #
+    # @return [Array] the crypted_key, plain_key
+    def generate_key
+      key   = OpenSSL::PKey::RSA.new(Base64.strict_decode64(KEY))
+      plain = Random.new.bytes(32)
+      padding = OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING
+
+      [key.public_encrypt(plain, padding), plain]
+    end
+
+    # Encrypts the given IO stream using the given key
+    #
+    # @example Encrypting data
+    #   crypto = Crypto.new
+    #   crypto.encrypt('data', 'key')
+    #
+    # @param io [#read] The IO object to encrypt
+    # @param key [String] The key
+    # @return [:read] an IO object represeting the encrypted data
+    def encrypt(io, key)
+      iv = Random.new.bytes(16)
+
+      iv_cipher = iv_cipher(key, :encrypt)
+      cipher    = data_cipher(key, iv, :encrypt)
+
+      StringIO.new(iv_cipher.update(iv) + iv_cipher.final +
+                   cipher.update(io.read) + cipher.final)
+    end
+
+    # Decrypts the given IO stream using the given key
+    #
+    # @example Encrypting data
+    #   crypto = Crypto.new
+    #   crypto.decrypt(StringIO.new('data'), 'key')
+    #
+    # @param io [#read] The IO object to encrypt
+    # @param key [String] The key
+    # @return [:read] an IO object represeting the decrypted data
+    def decrypt(io, key)
+      iv_cipher = iv_cipher(key, :decrypt)
+      crypted_iv = io.read(16)
+      iv = iv_cipher.update(crypted_iv) + iv_cipher.final
+
+      cipher = data_cipher(key, iv, :decrypt)
+
+      StringIO.new(cipher.update(io.read) + cipher.final)
+    end
+
+    # Get the 32 bit crc for the given key
+    #
+    # @param key [String] The key
+    # @return [Integer] the crc
+    def session_key_crc(key)
+      Zlib.crc32(key)
+    end
+
+    private
+
+    # @api private
+    def data_cipher(key, iv, type)
+      cipher = OpenSSL::Cipher::AES.new(256, :CBC)
+      cipher.send(type)
+      cipher.key = key
+      cipher.iv = iv
+      cipher
+    end
+
+    # @api private
+    def iv_cipher(key, type)
+      iv_cipher = OpenSSL::Cipher::AES.new(256, :ECB)
+      iv_cipher.send(type)
+      iv_cipher.key = key
+      iv_cipher.padding = 0
+      iv_cipher
+    end
+  end
+end

data/lib/steam/emsg_util.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Steam
+  # Utility to provide EMsg convenience. Allows looking up
+  # EMsg name by the EMsg integer value.
+  #
+  # EMsgUtil.new(123).name # => 'SOME_EMSG'
+  class EMsgUtil
+    # Instantiate the object
+    #
+    # @param emsg [Integer] the integer emsg value
+    def initialize(emsg)
+      @emsg = emsg
+    end
+
+    # Return the name of the EMsg
+    #
+    # @return [String]
+    def name
+      emsg.to_s
+    end
+
+    private
+
+    # @api private
+    def emsg
+      EMsg.constants.select { |x| EMsg.const_get(x) == @emsg }.first
+    end
+  end
+end

data/lib/steam/handler/auth.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+module Steam
+  module Handler
+    # Steam Auth handler. Handles channel encryption and decryption.
+    #
+    # @example Using the handler inside Handler::Collection
+    #   collection = Handler::Collection.new
+    #   collection << Handler::Auth.new
+    #   collection.handle(packet)
+    #
+    # @example Using the handler stand alone
+    #   handler = Handler::Auth.new
+    #   handler.handle_packet(packet)
+    class Auth
+      include Handler::Base
+
+      # Respond the Channel encrypt requests and results
+      handles EMsg::CHANNEL_ENCRYPT_REQUEST, EMsg::CHANNEL_ENCRYPT_RESULT
+
+      # Override the constructor to set our key to nil. This key will be
+      # used if the encryption is a success to decode and encode all future
+      # packet data.
+      def initialize(*)
+        super
+        @key = nil
+      end
+
+      # Handles the given packet. This handler is only concerned about the
+      # channel encryption request and result.
+      #
+      # @param packet [Networking::Packet] the packet to handle
+      def handle(packet)
+        case packet.msg_type
+        when EMsg::CHANNEL_ENCRYPT_REQUEST
+          handle_channel_encrypt_request(packet)
+        when EMsg::CHANNEL_ENCRYPT_RESULT
+          handle_channel_encrypt_result(packet)
+        end
+      end
+
+      private
+
+      # Decodes the packet as a MsgChannelEncryptResult. If the result is
+      # a success the client's connection session key is set.
+      #
+      # @param packet [Networking::Packet]
+      def handle_channel_encrypt_result(packet)
+        msg = packet.as_message(MsgChannelEncryptResult.new)
+        raise 'encrypt result failed' unless msg.body.result == EResult::OK
+
+        # Set the session key
+        client.session_key = @key
+        client.ready
+        Steam.logger.debug('Client channel encrypted')
+        true
+      end
+
+      # Decodes the packet as a MsgChannelEncryptResponse. A key is generated
+      # and sent to the steam servers. If the encryption request is a success
+      # the connection's session key is set in the handling of the result
+      #
+      # @param _packet [Networking::Packet]
+      def handle_channel_encrypt_request(_packet)
+        encrypt = Crypto.new
+        crypted_key, key = encrypt.generate_key
+
+        msg = ClientMessage.new(MsgHdr.new,
+                                MsgChannelEncryptResponse.new,
+                                EMsg::CHANNEL_ENCRYPT_RESPONSE)
+        msg.payload.write(crypted_key)
+        msg.payload.write_int64(encrypt.session_key_crc(crypted_key))
+
+        send_msg(msg)
+        @key = key
+      end
+    end
+  end
+end

data/lib/steam/handler/base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module Steam
+  module Handler
+    # Defines the base Handler
+    #
+    # @example Creating a handler
+    #   class MyHandler
+    #     include HandlerBase
+    #
+    #     handles :CLIENT_LOG_OFF
+    #
+    #     def handle(packet)
+    #     end
+    #   end
+    module Base
+      # Inject class methods into the hosting class
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+
+      # The Client object
+      #
+      # @see Client
+      attr_reader :client
+
+      # Instantiate a Handler with a Client
+      #
+      # @example Creating a Handler
+      #   class MyHandler
+      #     include Handler::Base
+      #   end
+      #
+      #   handler = MyHandler.new(Client.new)
+      def initialize(client)
+        @client = client
+      end
+
+      # Handle the incoming packet
+      #
+      # @param _packet [Networking::Packet] the packet to handle
+      def handle(_packet)
+        raise NotImplementedError
+      end
+
+      # Determines if this handler can handle the given message type. It
+      # compares the symbols given via .handles to known EMsg constants.
+      #
+      # @param msg [Integer]
+      # @return [Bool]
+      def handles?(msg)
+        self.class.handled_messages.any? { |m| msg == m }
+      end
+
+      # Send a message to the client
+      #
+      # @param msg [Message] The Message to send to steam
+      # @return [Bool]
+      def send_msg(msg)
+        @client.send_msg(msg)
+      end
+
+      # Inject methods into the hosting class
+      module ClassMethods
+        # The list of EMsgs that this handler knows
+        # how to handle
+        def handled_messages
+          @handled_messages ||= []
+        end
+
+        # Specify with EMsgs this Handler cares about
+        def handles(*args)
+          handled_messages << args.dup.flatten
+          handled_messages.flatten!
+          handled_messages.uniq!
+        end
+      end
+    end
+  end
+end

data/lib/steam/handler/collection.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Steam
+  module Handler
+    # Holds a collection of Handler objects
+    #
+    # @example Create a collection of Handler objects
+    #   collection = Handler::Collection.new
+    #   collection << MyHandler.new(client)
+    class Collection
+      include Enumerable
+
+      # Creates an empty list of handlers
+      def initialize
+        @handlers = []
+      end
+
+      # Handle a packet. If a handler is found that cares about this packet,
+      # the packet object is passed to the handler.
+      #
+      # @param packet [Networking::Packet] the packet to handle
+      def handle(packet)
+        handler = find_handler(packet.msg_type)
+
+        if handler.nil?
+          Steam.logger.debug("No hander found for: #{EMsgUtil.new(packet.emsg).name}")
+          return false
+        end
+
+        handler.handle(packet)
+      end
+
+      # Add a handler to the collection
+      #
+      # @param handlers [Array<Handler::Base>] the handler to add
+      def add(*handlers)
+        handlers.each do |handler|
+          @handlers << handler
+          Steam.logger.debug("Added handler #{handler.class.name}")
+        end
+      end
+
+      # Iterate through each Handler. Allows the collection to act as an
+      # Enumerable
+      def each(&block)
+        @handlers.each(&block)
+      end
+
+      private
+
+      # @api private
+      # :nocov:
+      def find_handler(msg)
+        message_handlers = @handlers.select do |handler|
+          handler.handles?(msg)
+        end
+        message_handlers.first
+      end
+    end
+  end
+end

data/lib/steam/handler/game_coordinator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+module Steam
+  module Handler
+    # Game coordinator handler
+    class GameCoordinator
+      include Handler::Base
+
+      # Describes the EMsgs this Handler cares about
+      handles EMsg::CLIENT_FROM_GC
+
+      # Send a message to the Game Coordinator
+      #
+      # @note you must have asked and been given a GC session
+      # @todo remove hardcoded app id
+      #
+      # @param msg [GcMessage] The message to send
+      # @return [Bool]
+      def send_msg(msg)
+        gcmsg = Steamclient::CMsgGCClient.new
+        gcmsg.appid = 730
+        gcmsg.msgtype = msg.header.msg
+        gcmsg.payload = msg.encode
+
+        header = MsgHdrProtoBuf.new
+        # header.proto.routing_appid = 730
+        gc = ProtobufMessage.new(header, gcmsg, EMsg::CLIENT_TO_GC)
+
+        client.send_msg(gc)
+      end
+
+      # Handle a packet
+      #
+      # @param packet [Networking::Packet] the packet to handle
+      def handle(packet)
+        case packet.msg_type
+        when EMsg::CLIENT_FROM_GC
+          handle_gc_message(packet)
+        end
+      end
+
+      # Tell the Steam servers that the Client is playing a game.
+      #
+      # @param game_id [Integer] the game to play
+      #
+      # @example Playing CS:GO
+      #   game_coordinator = client.game_coordinator
+      #   game_coordinator.play(730, "CS:GO")
+      def play(game_id)
+        game = Steamclient::CMsgClientGamesPlayed.new
+
+        played = Steamclient::CMsgClientGamesPlayed::GamePlayed.new
+        played.game_id = game_id
+        played.token = @client.connect_tokens.shift
+
+        game.games_played ||= [played]
+
+        msg = ProtobufMessage.new(MsgHdrProtoBuf.new, game,
+                                  EMsg::CLIENT_GAMES_PLAYED_WITH_DATA_BLOB)
+        client.send_msg(msg)
+      end
+
+      private
+
+      # @api private
+      def handle_gc_message(packet)
+        msg = packet.as_message(Steamclient::CMsgGCClient.new)
+
+        gcmsg = GcProtobufMessage.new(
+          MsgGCHdrProtoBuf.new,
+          msg.body,
+          msg.body.msgtype
+        )
+
+        client.gc_message(gcmsg)
+      end
+    end
+  end
+end

data/lib/steam/handler/steam_apps.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Steam
+  module Handler
+    # Steam apps handler
+    class SteamApps
+      include Handler::Base
+
+      # Describes the EMsgs this Handler cares about
+      handles EMsg::CLIENT_GAME_CONNECT_TOKENS
+
+      # Handle a packet
+      #
+      # @param packet [Networking::Packet] the packet to handle
+      def handle(packet)
+        case packet.msg_type
+        when EMsg::CLIENT_GAME_CONNECT_TOKENS
+          handle_client_game_connect_tokens(packet)
+        end
+      end
+
+      private
+
+      # Handles a packet that contains connect tokens. Connect tokens
+      # are required to tell the Steam servers you are playing a game.
+      #
+      # @param packet [Networking::Packet] the packet
+      def handle_client_game_connect_tokens(packet)
+        msg = packet.as_message(Steamclient::CMsgClientGameConnectTokens.new)
+
+        @client.update_connect_tokens(msg.body.tokens,
+                                      msg.body.max_tokens_to_keep)
+      end
+    end
+  end
+end

data/lib/steam/handler/steam_user.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Steam
+  module Handler
+    # Handles messages releated to a Steam user
+    #
+    # @example Logging in
+    #   steam_user = client.steam_user
+    #   steam_user.login(username, password, token, hash)
+    #
+    # @note You need to handle the LogonResponse to catch Steam Guard prompts
+    #   and 2FA
+    class SteamUser
+      include Handler::Base
+
+      handles EMsg::CLIENT_LOG_ON_RESPONSE, EMsg::CLIENT_UPDATE_MACHINE_AUTH,
+              EMsg::CLIENT_LOGGED_OFF, EMsg::CLIENT_NEW_LOGIN_KEY
+
+      # rubocop:disable MethodLength
+      # rubocop:disable AbcSize
+      #
+      # Log a Client in
+      #
+      # @param username [String] the username
+      # @param password [String] the password
+      # @param token [String] the SteamGuard token or nil
+      # @param hash [String] the SteamGuard hash or nil
+      #
+      # @return True or false if the message was sent. You must handle the
+      #   ClientLogonResponse to know the real logon result
+      def login(username, password, token = nil, hash = nil)
+        msg = ProtobufMessage.new(MsgHdrProtoBuf.new,
+                                  Steamclient::CMsgClientLogon.new,
+                                  EMsg::CLIENT_LOGON)
+
+        msg.body.auth_code = token if token
+        msg.body.eresult_sentryfile = EResult::FILE_NOT_FOUND
+
+        if hash
+          msg.body.sha_sentryfile = hash
+          msg.body.eresult_sentryfile = EResult::OK
+        end
+
+        ip = LocalIp.new.to_i ^ MsgClientLogon::OBFUSCATION_MASK
+        msg.body.obfustucated_private_ip = ip
+        msg.body.account_name = username
+        msg.body.password = password
+        msg.body.protocol_version = MsgClientLogon::CURRENT_PROTOCOL
+        msg.body.client_os_type = EOSType::WIN311
+        msg.body.client_package_version = 1771
+
+        send_msg(msg)
+      end
+
+      # Change the Client's persona state.
+      #
+      # @example Setting a Client as "Online"
+      #   steam_user = client.steam_user
+      #   steam_user.change_persona_state(EPersonaState::ONLINE)
+      #
+      # @param state [EMsg::E_PERSONA_STATE] the new client state
+      # @return True if the message was sent, false otherwise
+      def change_persona_state(state)
+        client_status = Steamclient::CMsgClientChangeStatus.new
+        client_status.persona_state = state
+
+        client_change_status = ProtobufMessage.new(MsgHdrProtoBuf.new,
+                                                   client_status,
+                                                   EMsg::CLIENT_CHANGE_STATUS)
+        send_msg(client_change_status)
+      end
+
+      # Change the Client's name
+      #
+      # @example Setting a Client as "Jimbo"
+      #   steam_user = client.steam_user
+      #   steam_user.change_persona_name("Jimbo")
+      #
+      # @param name [String] the new client name
+      # @return True if the message was sent, false otherwise
+      def change_persona_name(name)
+        client_status = Steamclient::CMsgClientChangeStatus.new
+        client_status.player_name = name
+
+        client_change_status = ProtobufMessage.new(MsgHdrProtoBuf.new,
+                                                   client_status,
+                                                   EMsg::CLIENT_CHANGE_STATUS)
+        send_msg(client_change_status)
+      end
+
+      # Logs the Client off the Steam network
+      #
+      # @return [Bool]
+      def logoff
+        logoff = ProtobufMessage.new(MsgHdrProtoBuf.new,
+                                     Steamclient::CMsgClientLogOff.new,
+                                     EMsg::CLIENT_LOG_OFF)
+        send_msg(logoff)
+      end
+
+      # Handles a given packet
+      #
+      # @param packet [Networking::Packet] the packet to handle
+      def handle(packet)
+        case packet.msg_type
+        when EMsg::CLIENT_LOG_ON_RESPONSE
+          handle_client_logon_response(packet)
+        when EMsg::CLIENT_UPDATE_MACHINE_AUTH
+          handle_machine_auth_update(packet)
+        when EMsg::CLIENT_NEW_LOGIN_KEY
+          handle_login_key(packet)
+        when EMsg::CLIENT_LOGGED_OFF
+          handle_client_logoff(packet)
+        end
+      end
+
+      private
+
+      # @api private
+      def handle_client_logoff(packet)
+        msg = packet.as_message(Steamclient::CMsgClientLoggedOff.new)
+        raise NotImplementedError, msg.inspect.to_s
+      end
+
+      # @api private
+      def handle_login_key(packet)
+        msg = packet.as_message(Steamclient::CMsgClientNewLoginKey.new)
+
+        resp = Steamclient::CMsgClientNewLoginKeyAccepted.new
+        resp.unique_id = msg.body.unique_id
+        resp = ProtobufMessage.new(MsgHdrProtoBuf.new,
+                                   resp, EMsg::CLIENT_NEW_LOGIN_KEY_ACCEPTED)
+        send_msg(resp)
+      end
+
+      # @api private
+      def handle_machine_auth_update(packet)
+        msg = packet.as_message(Steamclient::CMsgClientUpdateMachineAuth.new)
+        digest = Digest::SHA1.digest(msg.body.bytes)
+
+        resp = Steamclient::CMsgClientUpdateMachineAuthResponse.new
+        resp.sha_file = digest
+
+        file = SentryFile.new
+        file.write(digest)
+
+        header = MsgHdrProtoBuf.new
+        header.proto.jobid_target = msg.header.proto.jobid_source
+        resp = ProtobufMessage.new(header, resp,
+                                   EMsg::CLIENT_UPDATE_MACHINE_AUTH_RESPONSE)
+        send_msg(resp)
+      end
+
+      # @api private
+      def handle_client_logon_response(packet)
+        resp = packet.as_message(Steamclient::CMsgClientLogonResponse.new)
+
+        body = resp.body
+        proto = resp.header.proto
+        if body.eresult == EResult::OK && proto.client_sessionid.positive?
+          client.create_session(proto.steamid,
+                                proto.client_sessionid)
+          client.start_heartbeat(body.out_of_game_heartbeat_seconds)
+        end
+
+        client.on_logon(resp)
+      end
+    end
+  end
+end

data/lib/steam/handler.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Steam
+  # Messsage handlers
+  #
+  # @see Handler::Base
+  module Handler
+  end
+end
+
+require 'steam/handler/base'
+require 'steam/handler/collection'
+require 'steam/handler/auth'
+require 'steam/handler/steam_user'
+require 'steam/handler/steam_apps'
+require 'steam/handler/game_coordinator'

data/lib/steam/local_ip.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'socket'
+require 'ipaddr'
+
+module Steam
+  # Access to the Local IP
+  #
+  # @example Get Local IP
+  #   ip = LocalIp.new
+  #   ip.to_s # => '192.168.1.158'
+  #   ip.to_i # => 3232235934
+  class LocalIp
+    def initialize
+      @addr = Socket.ip_address_list.detect(&:ipv4_private?)
+    end
+
+    # Get the IP address as a string
+    #
+    # @return [String] the ip
+    def to_s
+      @addr.ip_address
+    end
+    alias address to_s
+
+    # Get the IP address as a int
+    #
+    # @return [Integer] the ip
+    def to_i
+      IPAddr.new(address).to_i
+    end
+  end
+end