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 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 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)
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
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 handle_message(self, emsg_real, msg):
emsg = Util.get_msg(emsg_real)
#print "EMsg is", Util.lookup_enum(EMsg, emsg)
if emsg == EMsg.ClientLogOnResponse:
self.handle_client_logon(msg)
elif emsg == EMsg.ClientUpdateMachineAuth:
self.handle_update_machine_auth(msg)
elif emsg == EMsg.ClientSessionToken:
self.handle_session_token(msg)
elif emsg == EMsg.ClientServerList:
self.handle_server_list(msg)
for listener in self.listeners:
listener.handle_message(emsg_real, msg)
if emsg in self.message_constructors:
constructor = self.message_constructors[emsg]
if constructor[2]:
message = constructor[0](constructor[1], constructor[2])
else:
message = constructor[0](constructor[1])
message.parse(msg)
if self.message_events.get(emsg):
self.message_events[emsg].set(message)
self.message_events[emsg] = None
if self.message_job_events.get(message.header.target_jobid):
self.message_job_events[message.header.target_jobid].set(message)
self.message_job_events[message.header.target_jobid] = None
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 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 handle_message(self, emsg_real, msg):
emsg = Util.get_msg(emsg_real)
#print "EMsg is", Util.lookup_enum(EMsg, emsg)
if emsg == EMsg.ClientLogOnResponse:
self.handle_client_logon(msg)
elif emsg == EMsg.ClientUpdateMachineAuth:
self.handle_update_machine_auth(msg)
elif emsg == EMsg.ClientSessionToken:
self.handle_session_token(msg)
elif emsg == EMsg.ClientServerList:
self.handle_server_list(msg)
for listener in self.listeners:
listener.handle_message(emsg_real, msg)
if emsg in self.message_constructors:
constructor = self.message_constructors[emsg]
if constructor[2]:
message = constructor[0](constructor[1], constructor[2])
else:
message = constructor[0](constructor[1])
message.parse(msg)
if self.message_events.get(emsg):
self.message_events[emsg].set(message)
self.message_events[emsg] = None
if self.message_job_events.get(message.header.target_jobid):
self.message_job_events[message.header.target_jobid].set(
message)
self.message_job_events[message.header.target_jobid] = None
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 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 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 dispatch_message(self, msg):
emsg_real, = struct.unpack_from('<I', msg)
emsg = Util.get_msg(emsg_real)
if emsg == EMsg.ChannelEncryptRequest:
gevent.spawn(self.channel_encrypt_request, msg)
elif emsg == EMsg.ClientLogOnResponse:
self.logon_response(msg)
elif emsg == EMsg.Multi:
self.split_multi_message(msg)
self.client.handle_message(emsg_real, msg)
def dispatch_message(self, msg):
emsg_real, = struct.unpack_from('<I', msg)
emsg = Util.get_msg(emsg_real)
if emsg == EMsg.ChannelEncryptRequest:
gevent.spawn(self.channel_encrypt_request, msg)
elif emsg == EMsg.ClientLogOnResponse:
self.logon_response(msg)
elif emsg == EMsg.Multi:
self.split_multi_message(msg)
self.client.handle_message(emsg_real, msg)
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 _make_request_url(self, action, params='', token=None):
absolute_uri = '/%s/%s' % (action, params)
url = 'http://%s:%s%s%s' % (self.host, self.port, absolute_uri, token if token else '')
if self.type == 'CDN':
return (url, {})
self.req_counter += 1
hash_buffer = struct.pack('<QQ', self.session_id, self.req_counter) + self.session_key + absolute_uri
sha_hash = Util.sha1_hash(hash_buffer, True)
headers = {'x-steam-auth': 'sessionid=%d;req-counter=%d;hash=%s;' % (self.session_id, self.req_counter, sha_hash)}
return (url, headers)
def _make_request_url(self, action, params='', token=None):
absolute_uri = '/%s/%s' % (action, params)
url = 'http://%s:%s%s%s' % (self.host, self.port, absolute_uri, token if token else '')
if self.type == 'CDN':
return (url, {})
self.req_counter += 1
hash_buffer = struct.pack('<QQ', self.session_id, self.req_counter) + self.session_key + absolute_uri
sha_hash = Util.sha1_hash(hash_buffer, True)
headers = {'x-steam-auth': 'sessionid=%d;req-counter=%d;hash=%s;' % (self.session_id, self.req_counter, sha_hash)}
return (url, headers)
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)
if 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 _make_request_url(self, action, params="", token=None):
absolute_uri = "/%s/%s" % (action, params)
url = "http://%s:%s%s%s" % (self.host, self.port, absolute_uri, token if token else "")
if self.type == "CDN":
return (url, {})
self.req_counter += 1
hash_buffer = struct.pack("<QQ", self.session_id, self.req_counter) + self.session_key + absolute_uri
sha_hash = Util.sha1_hash(hash_buffer, True)
headers = {
"x-steam-auth": "sessionid=%d;req-counter=%d;hash=%s;" % (self.session_id, self.req_counter, sha_hash)
}
return (url, headers)
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 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 handle_message(self, emsg, msg):
emsg = Util.get_msg(emsg)
if emsg == EMsg.ClientLoggedOff:
# Game already started on account
self.exit()
def handle_message(self, emsg, msg):
if logging == 2:
logEvent("Received message " + str(Util.get_msg(emsg)))
pass
def handle_message(self, emsg_real, msg): emsg = Util.get_msg(emsg_real) if emsg == EMsg.ClientLicenseList: self.handle_license_list(msg)
def handle_message(self, emsg, msg):
emsg = Util.get_msg(emsg)
if emsg == EMsg.ClientLoggedOff:
# Game already started on account
self.exit()
def handle_message(self, emsg, msg):
if logging == 2:
logEvent('Received message ' + str(Util.get_msg(emsg)))
pass
def handle_message(self, emsg_real, msg):
emsg = Util.get_msg(emsg_real)
if emsg == EMsg.ClientLicenseList:
self.handle_license_list(msg)
