def handle_update_machine_auth(self, msg):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientUpdateMachineAuth)
message.parse(msg)
sentryfile = message.body.bytes
hash = Util.sha1_hash(sentryfile)
self.callback.store_sentry_file(self.username, sentryfile)
response = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientUpdateMachineAuthResponse,
EMsg.ClientUpdateMachineAuthResponse)
response.header.target_jobid = message.header.source_jobid
response.body.cubwrote = message.body.cubtowrite
response.body.eresult = EResult.OK
response.body.filename = message.body.filename
response.body.filesize = message.body.cubtowrite
response.body.getlasterror = 0
response.body.offset = message.body.offset
response.body.sha_file = hash
response.body.otp_identifier = message.body.otp_identifier
response.body.otp_type = message.body.otp_type
self.connection.send_message(response)
def requestEconData(self, param_a, param_d, param_s=0, param_m=0):
message = msg_base.ProtobufMessage(
cstrike15_gcmessages_pb2.
CMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest,
csgo_base.ECSGOCMsg.
k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest)
message.body.param_s = param_s # SteamID
message.body.param_a = param_a # AssetID
message.body.param_d = param_d
message.body.param_m = param_m # MarketID
self.gc.gcSend(message)
response = self.gc.client.wait_for_message(EMsg.ClientFromGC,
timeout=5.0)
if response == 'Timed Out':
return 'Steam servers did not respond, your time delay is probably too small.'
elif Util.get_msg(
response.body.msgtype
) == csgo_base.ECSGOCMsg.k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse:
econData = self.gc.gcFrom(
response.body.payload, cstrike15_gcmessages_pb2.
CMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse)
return econData
else:
return 'Response was not of type EconPreviewDataBlockResponse'
def _heartbeat(self, time):
while self.socket:
sleep(time)
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientHeartBeat,
EMsg.ClientHeartBeat)
self.send_message(message)
def launch(self):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientGamesPlayed,
EMsg.ClientGamesPlayed)
message.body.games_played.add(game_id=self.appid)
self.gc.client.connection.send_message(message)
time.sleep(3)
try:
response = self.sendClientHello()
if Util.get_msg(
response.body.msgtype
) == csgo_base.EGCBaseClientMsg.k_EMsgGCClientWelcome:
logEvent('Launch successful!')
return True
else:
logEvent('Tried to launch, but got ' +
str(Util.get_msg(response.body.msgtype)))
return False
except Exception:
logEvent(
'Not connected, client hello failed to respond. (This is normal on first attempt)'
)
return False
def sendClientHello(self):
message = msg_base.ProtobufMessage(
gcsdk_gcmessages_pb2.CMsgClientHello,
csgo_base.EGCBaseClientMsg.k_EMsgGCClientHello)
self.gc.gcSend(message)
response = self.gc.client.wait_for_message(EMsg.ClientFromGC)
return response
def handle_client_logon(self, msg):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientLogonResponse)
message.parse(msg)
if message.body.steam2_ticket:
self.steam2_ticket = message.body.steam2_ticket
self.logon_event.set()
def logon_response(self, msg):
message = msg_base.ProtobufMessage(steammessages_clientserver_pb2.CMsgClientLogonResponse)
message.parse(msg)
if message.body.eresult == EResult.OK:
self.session_id = message.proto_header.client_sessionid
self.steamid = SteamID(message.proto_header.steamid)
delay = message.body.out_of_game_heartbeat_seconds
self.heartbeat = gevent.spawn(self._heartbeat, delay)
def get_depot_key(self, depot_id, app_id=0):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientGetDepotDecryptionKey,
EMsg.ClientGetDepotDecryptionKey)
message.body.depot_id = depot_id
message.body.app_id = app_id
response = self.client.wait_for_job(
message, EMsg.ClientGetDepotDecryptionKeyResponse)
return response.body
def handle_server_list(self, msg):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientServerList)
message.parse(msg)
for server in message.body.servers:
if not server.server_type in self.server_list:
self.server_list[server.server_type] = []
self.server_list[server.server_type].append(
(Util.long2ip(server.server_ip), server.server_port))
def login(self,
username=None,
password=None,
login_key=None,
auth_code=None,
steamid=0,
two_factor_code=None):
self.username = username
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientLogon, EMsg.ClientLogon)
message.proto_header.client_sessionid = 0
if steamid > 0:
message.proto_header.steamid = steamid
else:
message.proto_header.steamid = SteamID.make_from(
0, 0, EUniverse.Public, EAccountType.Individual).steamid
message.body.protocol_version = 65575
message.body.client_package_version = 1771
message.body.client_os_type = 10
message.body.client_language = "english"
message.body.machine_id = "OK"
message.body.account_name = username
message.body.password = password
if login_key:
message.body.login_key = login_key
if auth_code:
message.body.auth_code = auth_code
if two_factor_code:
message.body.two_factor_code = two_factor_code
sentryfile = self.callback.get_sentry_file(username)
if sentryfile:
message.body.sha_sentryfile = Util.sha1_hash(sentryfile)
message.body.eresult_sentryfile = EResult.OK
else:
message.body.eresult_sentryfile = EResult.FileNotFound
localip = self.connection.get_bound_address()
message.body.obfustucated_private_ip = 1111
self.connection.send_message(message)
logonResponse = self.wait_for_message(EMsg.ClientLogOnResponse)
if self.steamid:
self.account_type = self.steamid.accounttype
return logonResponse.body
def get_changes_since(self,
last_change_number,
send_app_changes=True,
send_package_changes=False):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgPICSChangesSinceRequest,
EMsg.PICSChangesSinceRequest)
message.body.since_change_number = last_change_number
message.body.send_app_info_changes = send_app_changes
message.body.send_package_info_changes = send_package_changes
response = self.client.wait_for_job(message,
EMsg.PICSChangesSinceResponse)
return response.body
def get_access_tokens(self, apps=None, packages=None):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgPICSAccessTokenRequest,
EMsg.PICSAccessTokenRequest)
if apps:
message.body.appids.extend(apps)
if packages:
message.body.packageids.extend(packages)
response = self.client.wait_for_job(message,
EMsg.PICSAccessTokenResponse)
return response.body
def gcSend(self, inputmsg):
Type = inputmsg.header.emsg
if logging == 2:
logEvent('gcSend ' + str(Util.get_msg(Type)))
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgGCClient, EMsg.ClientToGC)
message.header.routing_appid = self.appid
message.body.appid = self.appid
message.body.msgtype = Type | 0x80000000 if Util.is_proto(
Type) else Type
message.body.payload = inputmsg.serialize()
self.client.connection.send_message(message)
def login_anonymous(self):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientLogon, EMsg.ClientLogon)
message.proto_header.client_sessionid = 0
message.proto_header.steamid = SteamID.make_from(
0, 0, EUniverse.Public, EAccountType.AnonUser).steamid
message.body.protocol_version = 65575
message.body.client_os_type = 10
message.body.machine_id = "OK"
self.connection.send_message(message)
logonResponse = self.wait_for_message(EMsg.ClientLogOnResponse)
return logonResponse.body
def split_multi_message(self, msg):
message = msg_base.ProtobufMessage(steammessages_base_pb2.CMsgMulti)
message.parse(msg)
payload = message.body.message_body
if message.body.size_unzipped > 0:
zip_buffer = StringIO.StringIO(message.body.message_body)
with zipfile.ZipFile(zip_buffer, 'r') as zip:
payload = zip.read('z')
i = 0
while i < len(payload):
sub_size, = struct.unpack_from('<I', payload, i)
self.dispatch_message(payload[i+4:i+4+sub_size])
i += sub_size + 4
def get_cdn_auth_token(self, appid, host):
if self.cdn_token_cache.get((appid, host)):
return self.cdn_token_cache[(appid, host)]
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientGetCDNAuthToken,
EMsg.ClientGetCDNAuthToken)
message.body.app_id = appid
message.body.host_name = host
response = self.client.wait_for_job(message,
EMsg.ClientGetCDNAuthTokenResponse)
self.cdn_token_cache[(appid, host)] = response.body
return response.body
def get_app_ticket(self, appid):
if self.client.account_type != EAccountType.Individual:
return None
if self.ticket_cache.get(appid):
return self.ticket_cache[appid]
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientGetAppOwnershipTicket,
EMsg.ClientGetAppOwnershipTicket)
message.body.app_id = appid
response = self.client.wait_for_job(
message, EMsg.ClientGetAppOwnershipTicketResponse)
self.ticket_cache[appid] = response.body
return response.body
def get_product_info(self, apps=None, packages=None):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgPICSProductInfoRequest,
EMsg.PICSProductInfoRequest)
if apps:
for app in apps:
app_info = message.body.apps.add()
app_info.only_public = False
if isinstance(app, tuple):
app_info.appid, app_info.access_token = app
else:
app_info.appid = app
if packages:
for package in packages:
package_info = message.body.packages.add()
if isinstance(package, tuple):
package_info.appid, package_info.access_token = package
else:
package_info.packageid = package
message.body.meta_data_only = False
response = self.client.wait_for_job(message,
EMsg.PICSProductInfoResponse)
for app in response.body.apps:
self.app_cache[app.appid] = vdf.loads(app.buffer)['appinfo']
for package in response.body.packages:
kv = vdf.loadbinary(package.buffer[4:])
self.package_cache[package.packageid] = kv[0][str(
package.packageid)]
return response.body
def exit(self):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientGamesPlayed,
EMsg.ClientGamesPlayed)
self.gc.client.connection.send_message(message)
def logout(self):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientLogOff, EMsg.ClientLogOff)
self.connection.send_message(message)
return None
def handle_session_token(self, msg):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientSessionToken)
message.parse(msg)
self.session_token = message.body.token
def gcFrom(self, data, protobufType):
if logging == 2:
logEvent('gcFrom ' + str(protobufType))
message = msg_base.ProtobufMessage(protobufType)
message.parse(data)
return message.body
def handle_license_list(self, msg):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientLicenseList)
message.parse(msg)
self.licenses = message.body.licenses
def setState(self, state):
message = msg_base.ProtobufMessage(
steammessages_clientserver_pb2.CMsgClientChangeStatus,
EMsg.ClientChangeStatus)
message.body.persona_state = state
self.client.connection.send_message(message)
